refactor(schedule): make absolute times explicit

apps/web/tests/default-model.e2e.ts

@@ -41,7 +41,7 @@ describe('web e2e: the composer model switch is the default for later sessions',
   const createSession = async (sessionId: string): Promise<string> => {
     const response = await scaffold.ctx.apiProxy.sessions.create({
       rpcId: `default-model-create-${sessionId}` as never,
-      payload: { sessionId: SessionId(sessionId), cwd: scaffold.workspaceCwd, timeZone: 'UTC' },
+      payload: { sessionId: SessionId(sessionId), cwd: scaffold.workspaceCwd },
     })
     if (!response.result.ok) throw new Error(`session.create failed: ${response.result.error.message}`)
     return response.result.value.sessionId
@@ -150,7 +150,6 @@ describe('web e2e: the composer model switch is the default for later sessions',
         sessionId: SessionId(await createSession('default-model-refusal')),
         mode: 'queue' as const,
         content: [{ type: 'text' as const, text: 'hi' }],
-        clientTimeZone: 'UTC',
       },
     })
     expect(refused.result).toMatchObject({ ok: false, error: { code: 'model-unavailable' } })

apps/web/tests/scaffold.ts

@@ -196,8 +196,6 @@ export interface LaunchOptions {
   paceMs?: number
   /** Synthetic model capacity for UI scenarios whose seeded history must remain uncompacted. */
   replayContextWindow?: number
-  /** Caller-owned keyless adapter for a fixture that must derive its response at stream time. */
-  fixtureAdapter?: LlmAdapter
   /**
    * Tool presentation mode patched onto the shipped `tools` row (`code`
    * collapses the wire to run_code + the SDK prompt section). Omit for the
@@ -266,11 +264,6 @@ export async function launchWebScaffold(options: LaunchOptions = {}): Promise<We
   if (mode === 'record' && options.deepSeekMissingCredential === true) {
     throw new Error('deepSeekMissingCredential is a keyless replay/refresh option')
   }
-  if (options.fixtureAdapter !== undefined
-    && (mode === 'record' || options.replayFixture !== undefined
-      || options.deepSeekMissingCredential === true)) {
-    throw new Error('fixtureAdapter is exclusive with record, replayFixture, and deepSeekMissingCredential')
-  }
   const maskDeepSeekCredential = mode !== 'record' && options.deepSeekMissingCredential === true
   const originalDeepSeekCredential = process.env.DEEPSEEK_API_KEY
   let credentialEnvironmentRestored = false
@@ -449,8 +442,8 @@ export async function launchWebScaffold(options: LaunchOptions = {}): Promise<We
       // issues no model calls, and one that slipped in must not pass quietly.
       ctx.effect(() => ctx.llm.registerAdapter(
         replayProviders(options.replayContextWindow).map(provider => provider.id),
-        options.fixtureAdapter ?? new RouteOnlyAdapter(replayProviders(options.replayContextWindow)),
-      ), 'web e2e scaffold: fixture adapter')
+        new RouteOnlyAdapter(replayProviders(options.replayContextWindow)),
+      ), 'web e2e scaffold: route-only adapter')
     }
   } catch (error) {
     if (process.cwd() !== originalCwd) process.chdir(originalCwd)

apps/web/tests/schedule-after.e2e.ts

@@ -1,10 +1,5 @@
-// Keyless assembled-browser evidence for the opt-in Schedule overlay. A real
-// root Agent receives schedule_create through the complete tool pipeline; the
-// one-second owner path queues a best-effort followup, commits dispatch, and
-// renders the Host's durability-gated reminder sidecar. A separate browser
-// scenario drives local at through the real zone wire and model tool call.
-import { mkdtemp, realpath, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
+/** Keyless assembled-Web evidence for conversational Schedule delivery. */
+
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { Browser, Page } from 'playwright'
@@ -12,467 +7,358 @@ import { chromium } from 'playwright'
 import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
 import type { AgentHandle } from '@deepseek-ai/dsh-agent'
 import { CallId, createUserMessage, LlmAdapter } from '@deepseek-ai/dsh-llm'
-import type { GenerateOptions, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm'
-import { SessionId } from '@deepseek-ai/dsh-session'
-import type { Session } from '@deepseek-ai/dsh-session'
-import { RpcId } from '@deepseek-ai/dsh-host-apiproxy/api/rpc'
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
+import { SessionId, type SessionEvent } from '@deepseek-ai/dsh-session'
 import {
-  assertFixtureInventory, captureStableAria, compareOrRefreshGolden,
-  launchWebScaffold, watchConsole, webSnapshotMode, type WebScaffold,
+  assertFixtureInventory,
+  captureStableAria,
+  compareOrRefreshGolden,
+  launchWebScaffold,
+  watchConsole,
+  webSnapshotMode,
+  type WebScaffold,
 } from './scaffold.ts'
-import { connectFreshWorkspace, newEnglishPage, saveFailureShot } from './support.ts'
-import {
-  ScheduleId,
-  createAfterScheduleRecord,
-  foldScheduleEvents,
-} from '@deepseek-ai/dsh-tool-schedule'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const MODE = webSnapshotMode()
 const OVERLAY = fileURLToPath(new URL('../../../examples/web-schedule/cordis.yml', import.meta.url))
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/schedule-after', import.meta.url))
-const RECEIPT_EXPECTED = fileURLToPath(new URL('./snapshots/schedule-after/receipt.expected.md', import.meta.url))
-const AT_RECEIPT_EXPECTED = fileURLToPath(new URL('./snapshots/schedule-after/at-receipt.expected.md', import.meta.url))
-const SESSION_TIME_ZONE = 'UTC'
-const PROMPT = 'Check the deployment log'
+const AFTER_EXPECTED = join(SNAPSHOT_DIR, 'conversation.expected.md')
+const AT_EXPECTED = join(SNAPSHOT_DIR, 'at-conversation.expected.md')
+const AFTER_PROVIDER = 'schedule-after-web-test'
+const AT_PROVIDER = 'schedule-at-web-test'
+const MODEL = 'reply'
+const AFTER_PROMPT = 'Check the deployment log'
+const AFTER_REPLY = 'Reminder: Check the deployment log.'
+const AT_BROWSER_ZONE = 'Asia/Shanghai'
+const AT_USER_PROMPT = 'Remind me to review the release window in a few seconds in my local time.'
 const AT_PROMPT = 'Review the release window'
-const AT_RECEIPT_SELECTOR = '[data-schedule-reminder]:has-text("Review the release window")'
+const AT_READY = 'Ready for a browser-local reminder request.'
+const AT_ACK = 'Scheduled in your browser time zone.'
+const AT_REPLY = 'Reminder: Review the release window.'
 
-interface CreatedScheduleView {
-  id: string
-  kind: 'after' | 'at'
-  scheduledAt: string
-  deliveryMode: 'session-local'
+/** Emit one complete assistant text response. */
+function textResponse(text: string): StreamChunk[] {
+  return [
+    { type: 'block-start', index: 0, blockType: 'text' },
+    { type: 'block-end', index: 0, block: { type: 'text', text } },
+    { type: 'finish', reason: { kind: 'stop' } },
+  ]
 }
 
-/** Deterministic model boundary that selects local at relative to its actual first request. */
+/** Deterministic model seam that turns one due reminder into ordinary assistant prose. */
+class ReminderAdapter extends LlmAdapter {
+  override async * stream(_options: GenerateOptions): AsyncIterable<StreamChunk> {
+    yield * textResponse(AFTER_REPLY)
+  }
+}
+
+interface LocalAt {
+  readonly date: string
+  readonly time: string
+  readonly time_zone: string
+}
+
+/** Render one future epoch as exact local calendar fields in an explicit zone. */
+function localAt(epoch: number, timeZone: string): LocalAt {
+  const parts = Object.fromEntries(new Intl.DateTimeFormat('en-CA', {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hourCycle: 'h23',
+  }).formatToParts(epoch).map(part => [part.type, part.value])) as Record<string, string>
+  return {
+    date: `${parts['year']}-${parts['month']}-${parts['day']}`,
+    time: `${parts['hour']}:${parts['minute']}:${parts['second']}`,
+    time_zone: timeZone,
+  }
+}
+
+/** Dynamic model seam proving request-local browser context becomes an explicit At selector. */
 class BrowserZoneAtAdapter extends LlmAdapter {
   readonly requests: GenerateOptions[] = []
+  selectedAt: LocalAt | undefined
   scheduledAt: string | undefined
 
-  override resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo> {
-    return Promise.resolve({ provider, id: model, name: model, contextWindow: 128_000 })
-  }
-
   override async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
     this.requests.push(options)
     if (this.requests.length === 1) {
-      const target = Math.ceil((Date.now() + 10_000) / 1_000) * 1_000
-      const scheduledAt = new Date(target).toISOString()
-      this.scheduledAt = scheduledAt
-      const args = JSON.stringify({
-        prompt: AT_PROMPT,
-        at: { date: scheduledAt.slice(0, 10), time: scheduledAt.slice(11, 19) },
-      })
-      const callId = CallId('schedule-at-wire-call')
+      yield * textResponse(AT_READY)
+      return
+    }
+    if (this.requests.length === 2) {
+      const target = Math.ceil((Date.now() + 5_000) / 1_000) * 1_000
+      this.selectedAt = localAt(target, AT_BROWSER_ZONE)
+      this.scheduledAt = new Date(target).toISOString()
+      const argumentsJson = JSON.stringify({ prompt: AT_PROMPT, at: this.selectedAt })
+      const callId = CallId('schedule-at-browser-zone')
       yield { type: 'block-start', index: 0, blockType: 'tool-call' }
       yield {
-        type: 'tool-call-delta', index: 0, id: callId,
-        name: 'schedule_create', argumentsDelta: args,
+        type: 'tool-call-delta',
+        index: 0,
+        id: callId,
+        name: 'schedule_create',
+        argumentsDelta: argumentsJson,
       }
       yield {
-        type: 'block-end', index: 0,
-        block: { type: 'tool-call', id: callId, name: 'schedule_create', arguments: args },
+        type: 'block-end',
+        index: 0,
+        block: {
+          type: 'tool-call',
+          id: callId,
+          name: 'schedule_create',
+          arguments: argumentsJson,
+        },
       }
-      yield { type: 'usage', usage: { inputTokens: 256, outputTokens: 32 } }
       yield { type: 'finish', reason: { kind: 'tool-calls' } }
       return
     }
-    const text = this.requests.length === 2
-      ? 'The zone-aware reminder is scheduled.'
-      : 'The zone-aware reminder is due.'
-    yield { type: 'block-start', index: 0, blockType: 'text' }
-    yield { type: 'text-delta', index: 0, text }
-    yield { type: 'block-end', index: 0, block: { type: 'text', text } }
-    yield { type: 'usage', usage: { inputTokens: 128, outputTokens: 16 } }
-    yield { type: 'finish', reason: { kind: 'stop' } }
+    yield * textResponse(this.requests.length === 3 ? AT_ACK : AT_REPLY)
   }
 }
 
-/** Wait for one in-process lifecycle fact without using test-scoped expect.poll in beforeAll. */
-async function waitForFact(read: () => boolean, timeoutMs: number): Promise<void> {
+/** Extract text from one durable assistant message. */
+function assistantText(event: Extract<SessionEvent, { type: 'assistant/message' }>): string {
+  return event.data.message.content
+    .filter(block => block.type === 'text')
+    .map(block => block.text)
+    .join('')
+}
+
+/** Extract all model-visible text from one assembled request. */
+function requestText(options: GenerateOptions): string {
+  return options.messages
+    .flatMap(message => message.content)
+    .filter(block => block.type === 'text')
+    .map(block => block.text)
+    .join('\n')
+}
+
+/** Wait for one exact assistant reply and return its durable sequence. */
+async function waitForReply(handle: AgentHandle, text: string, timeoutMs: number): Promise<number> {
   const deadline = Date.now() + timeoutMs
-  while (!read()) {
-    if (Date.now() >= deadline) throw new Error(`Schedule lifecycle fact did not arrive within ${timeoutMs}ms`)
-    await new Promise(resolve => setTimeout(resolve, 20))
+  while (true) {
+    const event = handle.agent.session.events.find((candidate): candidate is SessionEvent<'assistant/message'> => (
+      candidate.type === 'assistant/message' && assistantText(candidate) === text
+    ))
+    if (event !== undefined) return event.seq
+    if (Date.now() >= deadline) throw new Error(`assistant reply did not arrive within ${timeoutMs}ms: ${text}`)
+    await new Promise<void>(resolve => setTimeout(resolve, 20))
   }
 }
 
-/** Give a seeded Session one completed turn so the real Host fork path can cut it. */
-function appendCompletedTurn(session: Session, prompt: string): void {
-  session.append('turn/start', { turn: 1 })
-  session.append('user/message', createUserMessage({
-    content: [{ type: 'text', text: prompt }],
-    source: { kind: 'user' },
-  }), { surfaceOp: 'append' })
-  session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
-}
-
-describe.skipIf(MODE === 'record')('web e2e: durable after reminder receipt', () => {
+describe.skipIf(MODE === 'record')('web e2e: conversational reminders', () => {
   let scaffold: WebScaffold
-  let agentHandle: AgentHandle
+  let afterHandle: AgentHandle
+  let atHandle: AgentHandle
   let browser: Browser
   let page: Page
-  let scheduleId = ''
+  let afterAssistantSeq = -1
+  let atAssistantSeq = -1
   let tripwire: ReturnType<typeof watchConsole>
+  const atAdapter = new BrowserZoneAtAdapter()
 
   beforeAll(async () => {
     scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY })
-    agentHandle = await scaffold.ctx.agents.create({
-      sessionId: SessionId('schedule-after-web-e2e'),
-      meta: { cwd: scaffold.workspaceCwd, timeZone: SESSION_TIME_ZONE },
-      agentOptions: { provider: 'deepseek-official', model: 'deepseek-v4-flash' },
-    })
-    const workspace = await scaffold.ctx.workspace.create(scaffold.workspaceCwd, 'Schedule')
-    await workspace.attachSession(agentHandle.agent.id)
-
-    const created = await scaffold.ctx.tools.execute({
-      signal: AbortSignal.timeout(10_000),
-      callId: CallId('schedule-after-create'),
-      name: 'schedule_create',
-      arguments: { prompt: PROMPT, after_seconds: 1 },
-      agent: agentHandle.agent,
-    })
-    expect(created.isError).toBe(false)
-    if (created.isError) throw new Error(created.error.message)
-    const value = created.value as unknown as CreatedScheduleView
-    expect(value.deliveryMode).toBe('session-local')
-    scheduleId = value.id
-    expect(scheduleId.length).toBeGreaterThan(0)
-
-    await waitForFact(() => agentHandle.agent.session.events.some(event =>
-      event.type === 'schedule/change'
-      && (event.data as { operation?: unknown }).operation === 'dispatch'), 15_000)
-    await expect(scaffold.ctx.sessions.flush(agentHandle.agent.session)).resolves.toBe(true)
-    const durable = await scaffold.ctx.sessionPersistence.inspect(agentHandle.agent.id)
-    expect(durable.meta).toMatchObject(agentHandle.agent.session.header)
-    expect({ ...durable.meta, delegationDepth: durable.meta.delegationDepth ?? 0 }).toEqual({
-      ...agentHandle.agent.session.header,
-      delegationDepth: agentHandle.agent.session.header.delegationDepth ?? 0,
-    })
-    expect(durable.events).toEqual(agentHandle.agent.session.events.slice(0, durable.events.length))
-    const history = await scaffold.ctx.apiProxy.sessions.history({
-      rpcId: RpcId('schedule-history-baseline'), payload: { sessionId: agentHandle.agent.id },
-    })
-    if (!history.result.ok) throw new Error(history.result.error.message)
-    expect(history.result.value.events?.find(entry =>
-      entry.event.type === 'schedule/change'
-      && (entry.event.data as { operation?: unknown }).operation === 'dispatch')?.view).toMatchObject({
-      for: 'event',
-    })
-    await waitForFact(
-      () => agentHandle.agent.session.events.some(event => event.type === 'turn/start'),
-      10_000,
+    scaffold.ctx.effect(
+      () => scaffold.ctx.llm.registerAdapter([AFTER_PROVIDER], new ReminderAdapter()),
+      'Schedule Web After adapter',
+    )
+    scaffold.ctx.effect(
+      () => scaffold.ctx.llm.registerAdapter([AT_PROVIDER], atAdapter),
+      'Schedule Web At adapter',
     )
-    await waitForFact(() => agentHandle.agent.session.events.some(event =>
-      event.type === 'user/message'
-      && (event.data as { source?: { plugin?: unknown } }).source?.plugin === 'time-context'), 10_000)
-    const timeReading = agentHandle.agent.session.events.find(event =>
-      event.type === 'user/message'
-      && event.data.source.kind === 'plugin'
-      && event.data.source.plugin === 'time-context')
-    if (timeReading?.type !== 'user/message') throw new Error('missing time-context reading')
-    const timeText = timeReading.data.content.find(block => block.type === 'text')?.text
-    if (timeText === undefined) throw new Error('missing time-context text')
-    expect(timeReading.data.source).toEqual({
-      kind: 'plugin',
-      plugin: 'time-context',
-      form: 'snapshot',
-      sections: [{ name: 'time-context', text: timeText }],
-    })
-    expect(timeText).toContain(`Session time zone: ${SESSION_TIME_ZONE}.`)
-    expect(timeText).toContain('Client time zone for this request: missing.')
-    const listed = await scaffold.ctx.apiProxy.sessions.list({
-      rpcId: RpcId('schedule-list-baseline'), payload: {},
-    })
-    if (!listed.result.ok) throw new Error(listed.result.error.message)
-    expect(listed.result.value.items.find(item => item.sessionId === agentHandle.agent.id)?.blank).toBe(false)
 
-    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 () => {
-    const failures: unknown[] = []
-    await browser?.close().catch((error: unknown) => failures.push(error))
-    await agentHandle?.dispose().catch((error: unknown) => failures.push(error))
-    await scaffold?.close().catch((error: unknown) => failures.push(error))
-    if (failures.length === 1) throw failures[0]
-    if (failures.length > 1) throw new AggregateError(failures, 'Schedule Web evidence teardown failed')
-  })
-
-  it('renders the committed reminder from attached history', async () => {
-    onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-after'))
-    const group = page.locator('[role="treeitem"]').first()
-    await group.waitFor({ timeout: 15_000 })
-    // Startup auto-selection can race the first disclosure gesture. Converge
-    // on the expanded state instead of letting that later update collapse it.
-    await expect.poll(async () => {
-      if (await group.getAttribute('aria-expanded') !== 'true') {
-        await group.click()
-        await page.waitForTimeout(50)
-      }
-      return await group.getAttribute('aria-expanded')
-    }, { timeout: 5_000 }).toBe('true')
-    const session = page.locator('[role="treeitem"][aria-selected]').nth(1)
-    await session.waitFor({ timeout: 10_000 })
-    await session.click()
-
-    const receipt = page.locator('[data-schedule-reminder]')
-    await receipt.waitFor({ timeout: 15_000 })
-    expect(await receipt.getByText(PROMPT, { exact: true }).count()).toBe(1)
-    expect(await receipt.getByText('Delivered in this session only', { exact: true }).count()).toBe(1)
-    const snapshot = (await captureStableAria(page, '[data-schedule-reminder]', scaffold.workspaceCwd))
-      .split(scheduleId).join('{{scheduleId}}')
-      .replace(/\d{4}-\d{2}-\d{2}T(?:\d{2}:\d{2}:\d{2}\.\d{3}|\{\{clock\}\})Z/gu, '{{occurrenceAt}}')
-    await compareOrRefreshGolden(RECEIPT_EXPECTED, snapshot, MODE)
-    expect(tripwire.pageErrors).toEqual([])
-    expect(tripwire.warnings).toEqual([])
-  }, 60_000)
-
-  it('keeps the fixture inventory closed', async () => {
-    await assertFixtureInventory(SNAPSHOT_DIR, ['at-receipt.expected.md', 'receipt.expected.md'])
-  })
-})
-
-describe.skipIf(MODE === 'record')('web e2e: browser-zone local at reminder', () => {
-  let scaffold: WebScaffold
-  let browser: Browser
-  let page: Page
-  let tripwire: ReturnType<typeof watchConsole>
-  const adapter = new BrowserZoneAtAdapter()
-
-  beforeAll(async () => {
-    scaffold = await launchWebScaffold({
-      extraOverlayPath: OVERLAY,
-      fixtureAdapter: adapter,
-    })
     browser = await chromium.launch()
     page = await browser.newPage({
       viewport: { width: 1680, height: 1000 },
       locale: 'en-US',
-      timezoneId: SESSION_TIME_ZONE,
+      timezoneId: AT_BROWSER_ZONE,
     })
     await page.addInitScript(() => { localStorage.setItem('dsh.locale', 'en') })
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
-    await connectFreshWorkspace(page, scaffold.workspaceCwd, 'schedule-at-wire-e2e')
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+    expect(await page.evaluate(() => Intl.DateTimeFormat().resolvedOptions().timeZone))
+      .toBe(AT_BROWSER_ZONE)
+
+    const cwd = join(scaffold.workspaceCwd, 'workspace')
+    const workspace = await scaffold.ctx.workspace.resolveByPath(cwd)
+    if (workspace === undefined) throw new Error('connected Web workspace was not registered')
+
+    afterHandle = await scaffold.ctx.agents.create({
+      sessionId: SessionId('schedule-after-web-e2e'),
+      meta: { cwd },
+      agentOptions: { provider: AFTER_PROVIDER, model: MODEL },
+    })
+    afterHandle.agent.session.append('session/title', {
+      title: 'Scheduled After follow-up',
+      messageSeqs: [],
+      source: { kind: 'user' },
+    })
+    await workspace.attachSession(afterHandle.agent.id)
+    const afterCreated = await scaffold.ctx.tools.execute({
+      signal: AbortSignal.timeout(10_000),
+      callId: CallId('schedule-after-create'),
+      name: 'schedule_create',
+      arguments: { prompt: AFTER_PROMPT, after_seconds: 1 },
+      agent: afterHandle.agent,
+    })
+    expect(afterCreated.isError).toBe(false)
+    afterAssistantSeq = await waitForReply(afterHandle, AFTER_REPLY, 15_000)
+    await afterHandle.agent.whenIdle()
+    await expect(scaffold.ctx.sessions.flush(afterHandle.agent.session)).resolves.toBe(true)
+
+    atHandle = await scaffold.ctx.agents.create({
+      sessionId: SessionId('schedule-at-web-e2e'),
+      meta: { cwd },
+      agentOptions: { provider: AT_PROVIDER, model: MODEL },
+    })
+    atHandle.agent.session.append('session/title', {
+      title: 'Explicit local-time reminder',
+      messageSeqs: [],
+      source: { kind: 'user' },
+    })
+    atHandle.agent.followup(createUserMessage({
+      content: [{ type: 'text', text: 'Prepare the reminder test session.' }],
+      source: { kind: 'plugin', plugin: 'schedule-web-e2e' },
+    }))
+    await atHandle.agent.whenIdle()
+    expect(atAdapter.requests).toHaveLength(1)
+    await expect(scaffold.ctx.sessions.flush(atHandle.agent.session)).resolves.toBe(true)
+    await workspace.attachSession(atHandle.agent.id)
+    await page.reload({ waitUntil: 'load' })
+    await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    const workspaceItem = page.locator('[role="treeitem"]').first()
+    await workspaceItem.waitFor({ timeout: 15_000 })
+    const expansionDeadline = Date.now() + 5_000
+    while (await workspaceItem.getAttribute('aria-expanded') !== 'true') {
+      if (Date.now() >= expansionDeadline) throw new Error('workspace item did not expand')
+      if (await workspaceItem.getAttribute('aria-expanded') !== 'true') {
+        await workspaceItem.click()
+      }
+      await new Promise<void>(resolve => setTimeout(resolve, 50))
+    }
+    const atSession = page.getByRole('treeitem', { name: /Explicit local-time reminder/ })
+    await atSession.waitFor({ timeout: 15_000 })
+    await atSession.click()
+    const composer = page.locator('textarea:enabled').last()
+    await composer.fill(AT_USER_PROMPT)
+    const settled = scaffold.whenTurnSettled(60_000)
+    await page.getByRole('button', { name: 'Send message', exact: true }).click()
+    expect(await settled).toBe(atHandle.agent.id)
+    await page.getByText(AT_ACK, { exact: true }).waitFor({ timeout: 15_000 })
+    atAssistantSeq = await waitForReply(atHandle, AT_REPLY, 20_000)
+    await atHandle.agent.whenIdle()
+    await expect(scaffold.ctx.sessions.flush(atHandle.agent.session)).resolves.toBe(true)
   }, 120_000)
 
   afterAll(async () => {
     const failures: unknown[] = []
     await browser?.close().catch((error: unknown) => failures.push(error))
+    await atHandle?.dispose().catch((error: unknown) => failures.push(error))
+    await afterHandle?.dispose().catch((error: unknown) => failures.push(error))
     await scaffold?.close().catch((error: unknown) => failures.push(error))
     if (failures.length === 1) throw failures[0]
-    if (failures.length > 1) throw new AggregateError(failures, 'Schedule at wire evidence teardown failed')
+    if (failures.length > 1) throw new AggregateError(failures, 'Schedule Web evidence teardown failed')
   })
 
-  it('carries the browser zone through prompt context, local at, and the durable receipt', async () => {
-    onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-at-wire'))
-    const composer = page.locator('textarea:enabled').last()
-    await composer.fill('Schedule the release-window reminder in my local time.')
-    const settled = scaffold.whenTurnSettled(60_000)
-    await page.getByRole('button', { name: 'Send message', exact: true }).click()
-    const sessionId = await settled
-    const agent = scaffold.ctx.agents.get(sessionId)
-    if (agent === undefined) throw new Error('browser-created Schedule Session has no live Agent')
-    expect(agent.session.header.timeZone).toBe(SESSION_TIME_ZONE)
+  it('renders After as an ordinary assistant follow-up', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-after'))
+    const session = page.getByRole('treeitem', { name: /Scheduled After follow-up/ })
+    await session.click()
+    const selector = `[data-chat-anchor-key="node:${String(afterAssistantSeq)}"]`
+    const row = page.locator(selector)
+    await row.waitFor({ timeout: 15_000 })
+    expect(await row.getAttribute('data-chat-flow-kind')).toBe('assistant')
+    expect(await row.textContent()).toContain(AFTER_REPLY)
+    await compareOrRefreshGolden(
+      AFTER_EXPECTED,
+      await captureStableAria(page, selector, scaffold.workspaceCwd),
+      MODE,
+    )
+    expect(await page.locator('[data-schedule-reminder]').count()).toBe(0)
+  }, 60_000)
 
-    const request = agent.session.events.find(event =>
+  it('uses request-local browser context to create an explicit local At reminder', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-schedule-at'))
+    const user = atHandle.agent.session.events.find(event => (
       event.type === 'user/message'
       && event.data.source.kind === 'user'
-      && event.data.content.some(block => block.type === 'text'
-        && block.text === 'Schedule the release-window reminder in my local time.'))
-    if (request?.type !== 'user/message' || request.data.source.kind !== 'user') {
+      && event.data.content.some(block => block.type === 'text' && block.text === AT_USER_PROMPT)
+    ))
+    if (user?.type !== 'user/message' || user.data.source.kind !== 'user') {
       throw new Error('missing browser user-rpc message')
     }
-    expect(request.data.source).toMatchObject({
-      kind: 'user',
-      clientTimeZone: SESSION_TIME_ZONE,
-    })
-    expect(typeof (request.data.source as { rpcId?: unknown }).rpcId).toBe('string')
+    expect(user.data.source).toMatchObject({ kind: 'user', clientTimeZone: AT_BROWSER_ZONE })
+    expect(typeof (user.data.source as { rpcId?: unknown }).rpcId).toBe('string')
 
-    const timeContextIndex = agent.session.events.findIndex(event =>
-      event.type === 'user/message'
-      && event.data.source.kind === 'plugin'
-      && event.data.source.plugin === 'time-context'
-      && event.data.content.some(block => block.type === 'text'
-        && block.text.includes('Session time zone: UTC.')
-        && block.text.includes('Client time zone for this request: UTC.')))
-    const toolCallIndex = agent.session.events.findIndex(event =>
-      event.type === 'tool/call' && event.data.name === 'schedule_create')
-    expect(timeContextIndex).toBeGreaterThanOrEqual(0)
-    expect(toolCallIndex).toBeGreaterThan(timeContextIndex)
-
-    const firstRequest = adapter.requests[0]
+    const firstRequest = atAdapter.requests[1]
     if (firstRequest === undefined) throw new Error('model did not receive the browser prompt')
-    expect(JSON.stringify(firstRequest.messages)).toContain('Session time zone: UTC.')
-    expect(JSON.stringify(firstRequest.messages)).toContain('Client time zone for this request: UTC.')
+    expect(requestText(firstRequest)).toContain(
+      `Browser time zone for this request: ${AT_BROWSER_ZONE}. `
+      + 'Interpret otherwise-unqualified dates and times in this zone.',
+    )
     expect(firstRequest.tools?.some(tool => tool.name === 'schedule_create')).toBe(true)
+    const selectedAt = atAdapter.selectedAt
+    const scheduledAt = atAdapter.scheduledAt
+    if (selectedAt === undefined || scheduledAt === undefined) {
+      throw new Error('model did not choose an explicit local At target')
+    }
+    expect(selectedAt.time_zone).toBe(AT_BROWSER_ZONE)
 
-    const scheduledAt = adapter.scheduledAt
-    if (scheduledAt === undefined) throw new Error('model did not choose a local at target')
-    const created = agent.session.events.find(event =>
+    const toolCall = atHandle.agent.session.events.find(event => (
+      event.type === 'tool/call' && event.data.name === 'schedule_create'
+    ))
+    if (toolCall?.type !== 'tool/call') throw new Error('missing schedule_create tool call')
+    expect(JSON.parse(toolCall.data.arguments)).toEqual({ prompt: AT_PROMPT, at: selectedAt })
+    const created = atHandle.agent.session.events.find(event => (
       event.type === 'schedule/change'
       && event.data.operation === 'create'
       && event.data.schedule.kind === 'at'
-      && event.data.schedule.scheduledAt === scheduledAt)
+    ))
     if (created?.type !== 'schedule/change' || created.data.operation !== 'create') {
-      throw new Error('local at tool call did not create its durable record')
+      throw new Error('explicit local At call did not create a durable record')
     }
-    const scheduleId = created.data.schedule.id
-    await waitForFact(() => agent.session.events.some(event =>
+    const schedule = created.data.schedule
+    expect(schedule).toMatchObject({
+      kind: 'at',
+      prompt: AT_PROMPT,
+      scheduledAt,
+    })
+    expect(atHandle.agent.session.events.filter(event => (
       event.type === 'schedule/change'
       && event.data.operation === 'dispatch'
-      && event.data.id === scheduleId), 20_000)
-    await agent.whenIdle()
-    expect(adapter.requests).toHaveLength(3)
-    await expect(scaffold.ctx.sessions.flush(agent.session)).resolves.toBe(true)
+      && event.data.id === schedule.id
+    ))).toHaveLength(1)
+    expect(atAdapter.requests).toHaveLength(4)
 
-    const history = await scaffold.ctx.apiProxy.sessions.history({
-      rpcId: RpcId('schedule-at-wire-history'),
-      payload: { sessionId },
-    })
-    if (!history.result.ok) throw new Error(history.result.error.message)
-    expect(history.result.value.events?.find(entry =>
-      entry.event.type === 'schedule/change'
-      && entry.event.data.operation === 'dispatch'
-      && entry.event.data.id === scheduleId)?.view).toMatchObject({
-      for: 'event',
-      view: { scheduleId, prompt: AT_PROMPT, occurrenceAt: scheduledAt },
-    })
-
-    const receipt = page.locator(AT_RECEIPT_SELECTOR)
-    await receipt.waitFor({ timeout: 20_000 })
-    const snapshot = (await captureStableAria(page, AT_RECEIPT_SELECTOR, scaffold.workspaceCwd))
-      .split(scheduleId).join('{{scheduleId}}')
-      .replace(/\d{4}-\d{2}-\d{2}T(?:\d{2}:\d{2}:\d{2}\.\d{3}|\{\{clock\}\})Z/gu, '{{occurrenceAt}}')
-    await compareOrRefreshGolden(AT_RECEIPT_EXPECTED, snapshot, MODE)
+    const session = page.getByRole('treeitem', { name: /Explicit local-time reminder/ })
+    await session.click()
+    const selector = `[data-chat-anchor-key="node:${String(atAssistantSeq)}"]`
+    const row = page.locator(selector)
+    await row.waitFor({ timeout: 15_000 })
+    expect(await row.getAttribute('data-chat-flow-kind')).toBe('assistant')
+    expect(await row.textContent()).toContain(AT_REPLY)
+    await compareOrRefreshGolden(
+      AT_EXPECTED,
+      await captureStableAria(page, selector, scaffold.workspaceCwd),
+      MODE,
+    )
+    expect(await page.locator('[data-schedule-reminder]').count()).toBe(0)
     expect(tripwire.pageErrors).toEqual([])
     expect(tripwire.warnings).toEqual([])
   }, 60_000)
-})
-
-describe.skipIf(MODE === 'record')('web e2e: Schedule restart, fork, and cold history', () => {
-  it('preserves pending work, commits one overdue receipt, and replays it cold without activation', async () => {
-    const workspaceCwd = await realpath(await mkdtemp(join(tmpdir(), 'dsh-schedule-restart-ws-')))
-    const persistenceRoot = await mkdtemp(join(tmpdir(), 'dsh-schedule-restart-sessions-'))
-    const world = { workspaceCwd, persistenceRoot }
-    const pendingId = SessionId('schedule-restart-pending')
-    const deliveredId = SessionId('schedule-restart-delivered')
-    let scaffold: WebScaffold | undefined
-    try {
-      scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY, world })
-      const workspace = await scaffold.ctx.workspace.create(workspaceCwd, 'Schedule restart')
-
-      const pending = scaffold.ctx.sessions.create(pendingId, { meta: { cwd: workspaceCwd } })
-      appendCompletedTurn(pending, 'pending parent turn')
-      pending.append('session/title', {
-        title: 'Pending restart session', messageSeqs: [], source: { kind: 'user' },
-      })
-      const pendingRecord = createAfterScheduleRecord(
-        ScheduleId('schedule-pending'), 'Pending across restart', 3_600, Date.now(),
-      )
-      pending.append('schedule/change', { version: 1, operation: 'create', schedule: pendingRecord })
-      await expect(scaffold.ctx.sessions.flush(pending)).resolves.toBe(true)
-      await workspace.attachSession(pendingId)
-
-      const delivered = scaffold.ctx.sessions.create(deliveredId, { meta: { cwd: workspaceCwd } })
-      appendCompletedTurn(delivered, 'delivered parent turn')
-      delivered.append('session/title', {
-        title: 'Delivered restart session', messageSeqs: [], source: { kind: 'user' },
-      })
-      const overdueRecord = createAfterScheduleRecord(
-        ScheduleId('schedule-delivered'), 'Delivered after restart', 1, Date.now() - 60_000,
-      )
-      delivered.append('schedule/change', { version: 1, operation: 'create', schedule: overdueRecord })
-      await expect(scaffold.ctx.sessions.flush(delivered)).resolves.toBe(true)
-      await workspace.attachSession(deliveredId)
-
-      await scaffold.close()
-      scaffold = undefined
-
-      scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY, world })
-      const pendingResume = await scaffold.ctx.apiProxy.sessions.create({
-        rpcId: RpcId('schedule-pending-resume'),
-        payload: { sessionId: pendingId, cwd: workspaceCwd, timeZone: 'UTC' },
-      })
-      if (!pendingResume.result.ok) throw new Error(pendingResume.result.error.message)
-      const pendingAgent = scaffold.ctx.agents.get(pendingId)
-      if (pendingAgent === undefined) throw new Error('pending Session did not resume')
-      expect(foldScheduleEvents(
-        pendingAgent.session.events,
-        pendingAgent.session.header.seedLength ?? 0,
-      ).active).toEqual([expect.objectContaining({ id: 'schedule-pending' })])
-
-      const forked = await scaffold.ctx.apiProxy.sessions.fork({
-        rpcId: RpcId('schedule-pending-fork'),
-        payload: { sessionId: pendingId },
-      })
-      if (!forked.result.ok) throw new Error(forked.result.error.message)
-      const child = scaffold.ctx.agents.get(forked.result.value.sessionId)
-      if (child === undefined) throw new Error('fork child was not published')
-      expect(foldScheduleEvents(
-        child.session.events,
-        child.session.header.seedLength ?? 0,
-      ).active).toEqual([])
-
-      const deliveredResume = await scaffold.ctx.apiProxy.sessions.create({
-        rpcId: RpcId('schedule-delivered-resume'),
-        payload: { sessionId: deliveredId, cwd: workspaceCwd, timeZone: 'UTC' },
-      })
-      if (!deliveredResume.result.ok) throw new Error(deliveredResume.result.error.message)
-      const deliveredAgent = scaffold.ctx.agents.get(deliveredId)
-      if (deliveredAgent === undefined) throw new Error('overdue Session did not resume')
-      await waitForFact(() => deliveredAgent.session.events.some(event =>
-        event.type === 'schedule/change' && event.data.operation === 'dispatch'), 15_000)
-      await deliveredAgent.whenIdle()
-      await expect(scaffold.ctx.sessions.flush(deliveredAgent.session)).resolves.toBe(true)
-      expect(deliveredAgent.session.events.filter(event =>
-        event.type === 'schedule/change' && event.data.operation === 'dispatch')).toHaveLength(1)
-
-      await scaffold.close()
-      scaffold = undefined
-
-      scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY, world })
-      expect(scaffold.ctx.agents.get(deliveredId)).toBeUndefined()
-      const coldHistory = await scaffold.ctx.apiProxy.sessions.history({
-        rpcId: RpcId('schedule-cold-history'),
-        payload: { sessionId: deliveredId },
-      })
-      if (!coldHistory.result.ok) throw new Error(coldHistory.result.error.message)
-      const dispatchEntries = coldHistory.result.value.events.filter(entry =>
-        entry.event.type === 'schedule/change'
-        && entry.event.data.operation === 'dispatch')
-      expect(dispatchEntries).toHaveLength(1)
-      expect(dispatchEntries[0]?.view?.for).toBe('event')
-      expect(scaffold.ctx.agents.get(deliveredId)).toBeUndefined()
-
-      await scaffold.close()
-      scaffold = undefined
-
-      scaffold = await launchWebScaffold({ extraOverlayPath: OVERLAY, world })
-      const replayed = await scaffold.ctx.apiProxy.sessions.create({
-        rpcId: RpcId('schedule-delivered-replay'),
-        payload: { sessionId: deliveredId, cwd: workspaceCwd, timeZone: 'UTC' },
-      })
-      if (!replayed.result.ok) throw new Error(replayed.result.error.message)
-      const replayedAgent = scaffold.ctx.agents.get(deliveredId)
-      if (replayedAgent === undefined) throw new Error('delivered Session did not resume again')
-      await replayedAgent.whenIdle()
-      await expect(scaffold.ctx.sessions.flush(replayedAgent.session)).resolves.toBe(true)
-      expect(replayedAgent.session.events.filter(event =>
-        event.type === 'schedule/change' && event.data.operation === 'dispatch')).toHaveLength(1)
-    } finally {
-      const failures: unknown[] = []
-      await scaffold?.close().catch((error: unknown) => failures.push(error))
-      await rm(workspaceCwd, { recursive: true, force: true }).catch((error: unknown) => failures.push(error))
-      await rm(persistenceRoot, { recursive: true, force: true }).catch((error: unknown) => failures.push(error))
-      if (failures.length === 1) throw failures[0]
-      if (failures.length > 1) throw new AggregateError(failures, 'Schedule restart evidence teardown failed')
-    }
-  }, 180_000)
+
+  it('keeps the fixture inventory closed', async () => {
+    await assertFixtureInventory(SNAPSHOT_DIR, [
+      'at-conversation.expected.md',
+      'conversation.expected.md',
+    ])
+  })
 })

apps/web/tests/smoke-real.e2e.ts

@@ -27,7 +27,6 @@ import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
 import { REPO_ROOT, connectFreshWorkspace, newEnglishPage, probeFreePort, requireDist, saveFailureShot } from './support.ts'
 
 const DEVELOPMENT_PROMPT = fileURLToPath(new URL('./snapshots/web-runtime-context/development-prompt.expected.md', import.meta.url))
-const WEB_TIME_ZONE = 'UTC'
 
 function waitForReadyLine(child: ChildProcess): Promise<string> {
   return new Promise((resolveReady, reject) => {
@@ -242,14 +241,11 @@ describe('dsh web keyless CLI smoke', () => {
     )
     try {
       const baseUrl = await waitForReadyLine(child)
-      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {
-        timeZone: WEB_TIME_ZONE,
-      })
+      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {})
       await rpc<{ accepted: true }>(baseUrl, 'session.prompt', {
         sessionId: created.sessionId,
         mode: 'queue',
         content: [{ type: 'text', text: 'go' }],
-        clientTimeZone: WEB_TIME_ZONE,
       })
       const capturedRequests = await Promise.race([
         providerRequests,
@@ -357,14 +353,11 @@ describe('dsh web keyless CLI smoke', () => {
     )
     try {
       const baseUrl = await waitForReadyLine(child)
-      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {
-        timeZone: WEB_TIME_ZONE,
-      })
+      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {})
       await rpc<{ accepted: true }>(baseUrl, 'session.prompt', {
         sessionId: created.sessionId,
         mode: 'queue',
         content: [{ type: 'text', text: promptMarker }],
-        clientTimeZone: WEB_TIME_ZONE,
       })
       let page: HistoryPage | undefined
       await expect.poll(async () => {
@@ -444,14 +437,11 @@ describe('dsh web keyless CLI smoke', () => {
     )
     try {
       const baseUrl = await waitForReadyLine(child)
-      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {
-        timeZone: WEB_TIME_ZONE,
-      })
+      const created = await rpc<{ sessionId: string }>(baseUrl, 'session.create', {})
       await rpc<{ accepted: true }>(baseUrl, 'session.prompt', {
         sessionId: created.sessionId,
         mode: 'queue',
         content: [{ type: 'text', text: 'go' }],
-        clientTimeZone: WEB_TIME_ZONE,
       })
       const captured = await Promise.race([
         providerRequest,

apps/web/tests/snapshots/schedule-after/at-conversation.expected.md

@@ -0,0 +1,6 @@
+- paragraph: "Reminder: Review the release window."
+- button "Copy":
+  - img
+- button "Branch into a new conversation":
+  - img
+- text: {{clock}} Ran for {{duration}}

apps/web/tests/snapshots/schedule-after/at-receipt.expected.md

@@ -1,6 +0,0 @@
-- note:
-  - banner: Scheduled reminder Delivered in this session only
-  - paragraph: Review the release window
-  - contentinfo:
-    - text: ID {{scheduleId}}
-    - time: Due at {{occurrenceAt}}

apps/web/tests/subagent-interrupt.e2e.ts

@@ -92,7 +92,6 @@ describe.skipIf(MODE === 'record')('web e2e: subagent.interrupt over the real co
     // A live parent Agent through the real API; no workspace or browser.
     const created = await rpc<{ sessionId: string }>(scaffold.baseUrl, 'session.create', {
       cwd: scaffold.workspaceCwd,
-      timeZone: 'UTC',
     })
     if (!created.ok) throw new Error(`session.create failed: ${created.error.code}`)
     parentId = sessionId(created.value.sessionId)