test(web): isolate sidebar subagent activity snapshot

apps/web/tests/sidebar-subagent-activity.e2e.ts

@@ -0,0 +1,152 @@
+import { mkdir } 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 type { AgentHandle } from '@deepseek-ai/dsh-agent'
+import { createUserMessage, LlmAdapter } from '@deepseek-ai/dsh-llm'
+import type { GenerateOptions, StreamChunk } from '@deepseek-ai/dsh-llm'
+import { SessionId, type SessionId as SessionIdValue } from '@deepseek-ai/dsh-session'
+import type {} from '@deepseek-ai/dsh-subagent'
+import type {} from '@deepseek-ai/dsh-workspace'
+import {
+  assertFixtureInventory,
+  captureStableAria,
+  compareOrRefreshGolden,
+  launchWebScaffold,
+  watchConsole,
+  webSnapshotMode,
+  type WebScaffold,
+} from './scaffold.ts'
+import { connectFreshWorkspace, newEnglishPage, saveFailureShot } from './support.ts'
+
+const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/sidebar-subagent-activity', import.meta.url))
+const RUNNING_OWNER_EXPECTED = join(SNAPSHOT_DIR, 'owner-running.expected.md')
+const MODE = webSnapshotMode()
+const HOLD_PROVIDER = 'web-test-hold'
+const HOLD_MODEL = 'hold'
+
+/** Model seam that completes the owner turn, then holds its delegated child open. */
+class StagedAdapter extends LlmAdapter {
+  activeCalls = 0
+  private calls = 0
+
+  override async *stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
+    if (this.calls === 0) {
+      this.calls += 1
+      yield { type: 'finish', reason: { kind: 'stop' } }
+      return
+    }
+    this.calls += 1
+    const signal = options.signal
+    if (signal === undefined) throw new Error('staged Web adapter requires a turn signal')
+    this.activeCalls += 1
+    try {
+      await new Promise<never>((_resolve, reject) => {
+        const abort = (): void => {
+          reject(signal.reason instanceof Error ? signal.reason : new Error('holding Web adapter aborted'))
+        }
+        if (signal.aborted) abort()
+        else signal.addEventListener('abort', abort, { once: true })
+      })
+    } finally {
+      this.activeCalls -= 1
+    }
+  }
+}
+
+async function waitForRunningChild(
+  scaffold: WebScaffold,
+  adapter: StagedAdapter,
+  childId: SessionIdValue,
+): Promise<void> {
+  const deadline = Date.now() + 10_000
+  while (adapter.activeCalls !== 1 || scaffold.ctx.agents.get(childId)?.status !== 'running') {
+    if (Date.now() >= deadline) throw new Error('held child did not enter its running model call')
+    await new Promise<void>(resolve => setTimeout(resolve, 10))
+  }
+}
+
+describe('web e2e: sidebar subagent activity', () => {
+  let scaffold: WebScaffold
+  let browser: Browser
+  let page: Page
+  let parentHandle: AgentHandle
+  let childId: SessionIdValue
+  let adapter: StagedAdapter
+  let tripwire: ReturnType<typeof watchConsole>
+
+  beforeAll(async () => {
+    scaffold = await launchWebScaffold()
+    adapter = new StagedAdapter()
+    scaffold.ctx.effect(
+      () => scaffold.ctx.llm.registerAdapter([HOLD_PROVIDER], adapter),
+      'sidebar subagent activity staged adapter',
+    )
+    const cwd = join(scaffold.workspaceCwd, 'workspace')
+    await mkdir(cwd)
+    parentHandle = await scaffold.ctx.agents.create({
+      sessionId: SessionId('sidebar-activity-owner'),
+      meta: { cwd },
+      agentOptions: { provider: HOLD_PROVIDER, model: HOLD_MODEL },
+    })
+    parentHandle.agent.followup(createUserMessage({
+      content: [{ type: 'text', text: 'Delegate a background task.' }],
+      source: { kind: 'user' },
+    }))
+    await parentHandle.agent.whenIdle()
+    const started = await scaffold.ctx.subagents.startContinuable({
+      provider: 'spawn',
+      label: 'sidebar activity child',
+      signal: new AbortController().signal,
+      request: {
+        prompt: [{ type: 'text', text: 'Hold this delegated task open.' }],
+        parent: parentHandle.agent,
+      },
+    })
+    childId = started.childId
+    await waitForRunningChild(scaffold, adapter, childId)
+
+    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 })
+    await connectFreshWorkspace(page, scaffold.workspaceCwd)
+    const workspace = await scaffold.ctx.workspace.resolveByPath(cwd)
+    if (workspace === undefined) throw new Error('connected Web workspace was not registered')
+    await workspace.attachSession(parentHandle.agent.session.id)
+  }, 60_000)
+
+  afterAll(async () => {
+    const failures: unknown[] = []
+    const child = childId === undefined ? undefined : scaffold?.ctx.agents.get(childId)
+    if (child !== undefined) {
+      child.cancel({ kind: 'user' })
+      await child.whenIdle().catch((error: unknown) => failures.push(error))
+    }
+    await browser?.close().catch((error: unknown) => failures.push(error))
+    await parentHandle?.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, 'sidebar subagent activity teardown failed')
+  })
+
+  it('pins a running descendant on its visible idle owner row', async () => {
+    onTestFailed(() => saveFailureShot(page, 'web-e2e-sidebar-subagent-activity'))
+    const sidebar = page.getByRole('tree', { name: 'Sessions' })
+    const ownerRow = sidebar.getByRole('treeitem', { name: /1 subagent running Delegate a background task/ })
+    await ownerRow.waitFor({ timeout: 10_000 })
+    expect(parentHandle.agent.status).toBe('idle')
+    await compareOrRefreshGolden(
+      RUNNING_OWNER_EXPECTED,
+      await captureStableAria(page, '[role="tree"][aria-label="Sessions"]', scaffold.workspaceCwd),
+      MODE,
+    )
+    expect(await ownerRow.locator('[data-state="ongoing"]').count()).toBe(1)
+    await assertFixtureInventory(SNAPSHOT_DIR, ['owner-running.expected.md'])
+    expect(tripwire.pageErrors).toEqual([])
+    expect(tripwire.warnings).toEqual([])
+  })
+})

apps/web/tests/snapshots/sidebar-subagent-activity/owner-running.expected.md

@@ -0,0 +1,6 @@
+- tree "Sessions":
+  - treeitem "workspace 2 sessions" [expanded]:
+    - img
+    - text: workspace 2 sessions
+  - treeitem "1 subagent running Delegate a background task. now"
+  - treeitem "New Session" [selected]

apps/web/tests/snapshots/subagent-conversation/sidebar-running.expected.md

@@ -1,5 +0,0 @@
-- tree "Sessions":
-  - treeitem "workspace 1 session" [expanded]:
-    - img
-    - text: workspace 1 session
-  - treeitem "1 subagent running Ask a research subagent to now" [selected]

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

@@ -23,7 +23,6 @@ const TREE_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/t
 const BRANCHLESS_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/branchless.expected.md', import.meta.url))
 const STALE_CATALOG_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/stale-catalog.expected.md', import.meta.url))
 const SIDEBAR_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/sidebar.expected.md', import.meta.url))
-const RUNNING_SIDEBAR_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/sidebar-running.expected.md', import.meta.url))
 const UNAVAILABLE_GRANDCHILD_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/nested.expected.md', import.meta.url))
 const FORK_EXPECTED = fileURLToPath(new URL('./snapshots/subagent-conversation/fork.expected.md', import.meta.url))
 const MODE = webSnapshotMode()
@@ -368,15 +367,6 @@ describe('web e2e: persisted subagent conversation and human continuation', () =
     ).toBe('running')
     const hierarchy = page.getByRole('navigation', { name: 'Session hierarchy' })
     await hierarchy.getByRole('button').first().click()
-    const runningOwnerRow = page.getByRole('tree', { name: 'Sessions' })
-      .getByRole('treeitem', { name: /1 subagent running/ })
-    await runningOwnerRow.waitFor({ timeout: 10_000 })
-    expect(await runningOwnerRow.locator('[data-state="ongoing"]').count()).toBe(1)
-    await compareOrRefreshGolden(
-      RUNNING_SIDEBAR_EXPECTED,
-      await captureStableAria(page, '[role="tree"][aria-label="Sessions"]', scaffold.workspaceCwd),
-      MODE,
-    )
     const runningTrigger = page.getByRole('button', { name: '3 subagents running' })
     await runningTrigger.waitFor({ timeout: 10_000 })
     expect(await runningTrigger.locator('[data-state="ongoing"]').count()).toBe(1)