-
+
diff --git a/src/renderer/src/lib/browser-palette-search.test.ts b/src/renderer/src/lib/browser-palette-search.test.ts
index 41cfd58f54d..759e1cc5421 100644
--- a/src/renderer/src/lib/browser-palette-search.test.ts
+++ b/src/renderer/src/lib/browser-palette-search.test.ts
@@ -102,6 +102,26 @@ describe('browser-palette-search', () => {
expect(result.executionHostId).toBe('ssh:box')
})
+ it('carries the page favicon into palette results', () => {
+ const faviconUrl = 'https://example.com/favicon.ico'
+ const [result] = searchBrowserPages(
+ [
+ makeEntry({
+ page: makePage({ faviconUrl }),
+ workspace: makeWorkspace(),
+ worktree: makeWorktree(),
+ repoName: 'repo/one',
+ worktreeSortIndex: 0,
+ isCurrentPage: false,
+ isCurrentWorktree: false
+ })
+ ],
+ ''
+ )
+
+ expect(result.faviconUrl).toBe(faviconUrl)
+ })
+
it('keeps empty-query ordering deterministic and context-first', () => {
const results = searchBrowserPages(
[
diff --git a/src/renderer/src/lib/browser-palette-search.ts b/src/renderer/src/lib/browser-palette-search.ts
index 1529c46860e..0cd9f7e0618 100644
--- a/src/renderer/src/lib/browser-palette-search.ts
+++ b/src/renderer/src/lib/browser-palette-search.ts
@@ -42,6 +42,7 @@ export type BrowserPaletteSearchResult = {
workspaceId: string
worktreeId: string
title: string
+ faviconUrl: string | null
/** Raw page URL, so callers can dedupe a row against another list of destinations. */
url: string
secondaryText: string
@@ -153,6 +154,7 @@ function baseResult(entry: SearchableBrowserPage): BrowserPaletteSearchResult {
workspaceId: entry.workspace.id,
worktreeId: entry.worktree.id,
title: entry.page.title || formattedUrl,
+ faviconUrl: entry.page.faviconUrl,
url: entry.page.url,
secondaryText: formattedUrl,
workspaceLabel: entry.workspace.label ?? null,
diff --git a/src/renderer/src/store/slices/browser.test.ts b/src/renderer/src/store/slices/browser.test.ts
index ba014db3aa3..fc1620871d5 100644
--- a/src/renderer/src/store/slices/browser.test.ts
+++ b/src/renderer/src/store/slices/browser.test.ts
@@ -302,6 +302,53 @@ describe('createBrowserSlice annotations', () => {
expect(store.getState().browserTabsByWorktree).toBe(browserTabsByWorktree)
})
+ it('persists a captured favicon with history and refreshes it with the page state', () => {
+ const store = createTestStore()
+ const tab = store.getState().createBrowserTab('wt-1', 'https://example.com', {
+ title: 'Example'
+ })
+ const pageId = tab.activePageId
+ if (!pageId) {
+ throw new Error('Expected a new browser page')
+ }
+ const initialFavicon = 'https://example.com/favicon.ico'
+ const refreshedFavicon = 'https://cdn.example.com/favicon.png'
+
+ store.getState().addBrowserHistoryEntry('https://example.com', 'Example', initialFavicon)
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBe(initialFavicon)
+
+ store.getState().updateBrowserPageState(pageId, { faviconUrl: refreshedFavicon })
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBe(refreshedFavicon)
+ })
+
+ it('clears a stale history favicon when a page reports none, and keeps it when none is reported', () => {
+ const store = createTestStore()
+ const tab = store.getState().createBrowserTab('wt-1', 'https://example.com', {
+ title: 'Example'
+ })
+ const pageId = tab.activePageId
+ if (!pageId) {
+ throw new Error('Expected a new browser page')
+ }
+ const favicon = 'https://example.com/favicon.ico'
+
+ store.getState().addBrowserHistoryEntry('https://example.com', 'Example', favicon)
+ store.getState().updateBrowserPageState(pageId, { faviconUrl: favicon })
+
+ // An omitted favicon leaves the stored one alone; an explicit null clears it.
+ store.getState().addBrowserHistoryEntry('https://example.com', 'Example')
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBe(favicon)
+
+ store.getState().updateBrowserPageState(pageId, { faviconUrl: null })
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBeNull()
+
+ store.getState().addBrowserHistoryEntry('https://example.com', 'Example', favicon)
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBe(favicon)
+
+ store.getState().addBrowserHistoryEntry('https://example.com', 'Example', null)
+ expect(store.getState().browserUrlHistory[0]?.faviconUrl).toBeNull()
+ })
+
it('repairs a stale active browser unified-tab label on an otherwise unchanged title update', () => {
const store = createTestStore()
const tab = store.getState().createBrowserTab('wt-1', 'https://example.com', {
diff --git a/src/renderer/src/store/slices/browser/browser-history-actions.ts b/src/renderer/src/store/slices/browser/browser-history-actions.ts
index 97ebf8b873b..85c5b4f5479 100644
--- a/src/renderer/src/store/slices/browser/browser-history-actions.ts
+++ b/src/renderer/src/store/slices/browser/browser-history-actions.ts
@@ -60,7 +60,7 @@ export function createBrowserHistoryActions(
})
},
- addBrowserHistoryEntry: (url, title) => {
+ addBrowserHistoryEntry: (url, title, faviconUrl) => {
const safeUrl = redactKagiSessionToken(url)
if (safeUrl === ORCA_BROWSER_BLANK_URL || safeUrl === 'about:blank' || !safeUrl) {
return
@@ -71,7 +71,13 @@ export function createBrowserHistoryActions(
let next: BrowserHistoryEntry[] = existing
? s.browserUrlHistory.map((entry) =>
entry === existing
- ? { ...entry, title, lastVisitedAt: Date.now(), visitCount: entry.visitCount + 1 }
+ ? {
+ ...entry,
+ title,
+ ...(faviconUrl !== undefined ? { faviconUrl } : {}),
+ lastVisitedAt: Date.now(),
+ visitCount: entry.visitCount + 1
+ }
: entry
)
: [
@@ -79,6 +85,7 @@ export function createBrowserHistoryActions(
url: safeUrl,
normalizedUrl: normalized,
title,
+ ...(faviconUrl !== undefined ? { faviconUrl } : {}),
lastVisitedAt: Date.now(),
visitCount: 1
},
diff --git a/src/renderer/src/store/slices/browser/browser-page-state-actions.ts b/src/renderer/src/store/slices/browser/browser-page-state-actions.ts
index 15e4892b351..83aa3c23673 100644
--- a/src/renderer/src/store/slices/browser/browser-page-state-actions.ts
+++ b/src/renderer/src/store/slices/browser/browser-page-state-actions.ts
@@ -9,6 +9,7 @@ import {
normalizeBrowserTitle,
normalizeUrl
} from '../browser-page-records'
+import { normalizeBrowserHistoryUrl } from '../../../../../shared/workspace-session-browser-history'
export function createBrowserPageStateActions(
set: BrowserSliceSet,
@@ -100,6 +101,17 @@ export function createBrowserPageStateActions(
[workspace.id]: nextPages
}
}
+ if (updates.faviconUrl !== undefined && updates.faviconUrl !== page.faviconUrl) {
+ const historyIndex = s.browserUrlHistory.findIndex(
+ (entry) => entry.normalizedUrl === normalizeBrowserHistoryUrl(page.url)
+ )
+ const historyEntry = s.browserUrlHistory[historyIndex]
+ if (historyEntry && historyEntry.faviconUrl !== updates.faviconUrl) {
+ nextState.browserUrlHistory = s.browserUrlHistory.map((entry, index) =>
+ index === historyIndex ? { ...entry, faviconUrl: updates.faviconUrl } : entry
+ )
+ }
+ }
if (!browserWorkspaceMirrorFieldsEqual(workspace, nextWorkspace)) {
nextState.browserTabsByWorktree = {
...s.browserTabsByWorktree,
diff --git a/src/renderer/src/store/slices/browser/browser-slice-contract.ts b/src/renderer/src/store/slices/browser/browser-slice-contract.ts
index c5577aaf0c4..ee50fa1a087 100644
--- a/src/renderer/src/store/slices/browser/browser-slice-contract.ts
+++ b/src/renderer/src/store/slices/browser/browser-slice-contract.ts
@@ -239,7 +239,7 @@ export type BrowserSlice = {
) => Promise
clearDefaultSessionCookies: () => Promise
browserUrlHistory: BrowserHistoryEntry[]
- addBrowserHistoryEntry: (url: string, title: string) => void
+ addBrowserHistoryEntry: (url: string, title: string, faviconUrl?: string | null) => void
workspaceDocHistory: WorkspaceDocHistoryEntry[]
/** A visit bumps recency and count; a title-only refresh (bump: false) renames the row. */
recordWorkspaceDocVisit: (
diff --git a/src/shared/browser-workspace-types.ts b/src/shared/browser-workspace-types.ts
index 5b2a1e7f33d..ecab57c8783 100644
--- a/src/shared/browser-workspace-types.ts
+++ b/src/shared/browser-workspace-types.ts
@@ -2,6 +2,7 @@ export type BrowserHistoryEntry = {
url: string
normalizedUrl: string
title: string
+ faviconUrl?: string | null
lastVisitedAt: number
visitCount: number
}
diff --git a/src/shared/workspace-session-browser-schema.ts b/src/shared/workspace-session-browser-schema.ts
index 71f88fb3b0c..159905e5ab9 100644
--- a/src/shared/workspace-session-browser-schema.ts
+++ b/src/shared/workspace-session-browser-schema.ts
@@ -117,6 +117,7 @@ const browserHistoryEntrySchema = z.object({
url: z.string(),
normalizedUrl: z.string(),
title: z.string(),
+ faviconUrl: z.string().nullable().optional(),
lastVisitedAt: z.number(),
visitCount: z.number()
})
diff --git a/src/shared/workspace-session-schema.test.ts b/src/shared/workspace-session-schema.test.ts
index 66e2ddcc514..81bc37b6b65 100644
--- a/src/shared/workspace-session-schema.test.ts
+++ b/src/shared/workspace-session-schema.test.ts
@@ -504,6 +504,7 @@ describe('parseWorkspaceSession', () => {
url: `https://example.com/${index}`,
normalizedUrl: `https://example.com/${index}`,
title: `Example ${index}`,
+ faviconUrl: index === 0 ? 'https://example.com/favicon.ico' : null,
lastVisitedAt: 1_700_000_000_000 - index,
visitCount: 1
}))
@@ -512,6 +513,9 @@ describe('parseWorkspaceSession', () => {
expect(result.ok).toBe(true)
if (result.ok) {
expect(result.value.browserUrlHistory).toHaveLength(MAX_BROWSER_HISTORY_ENTRIES)
+ expect(result.value.browserUrlHistory?.[0]?.faviconUrl).toBe(
+ 'https://example.com/favicon.ico'
+ )
expect(result.value.browserUrlHistory?.at(-1)?.url).toBe('https://example.com/199')
}
})
From 6062edf2962e1dc33c09d1be6bfd5a9469e969b8 Mon Sep 17 00:00:00 2001
From: Jinjing <6427696+AmethystLiang@users.noreply.github.com>
Date: Wed, 2 Sep 2026 10:39:46 -0700
Subject: [PATCH 04/26] test: simplify remote pane link routing to
server-hosted placement (#18219)
Remote-pane links are now explicitly server-hosted regardless of generic
client-hosted preference. Remove client-hosted placement verification,
placement-switching test acts, and related type definitions. Focus the
test on verifying the core invariant: links stay server-hosted on their
owning runtime.
---
...d-remote-browser-link-open-routing.spec.ts | 139 ++++--------------
1 file changed, 29 insertions(+), 110 deletions(-)
diff --git a/tests/e2e/paired-remote-browser-link-open-routing.spec.ts b/tests/e2e/paired-remote-browser-link-open-routing.spec.ts
index 695d39c251b..a8b15d97a03 100644
--- a/tests/e2e/paired-remote-browser-link-open-routing.spec.ts
+++ b/tests/e2e/paired-remote-browser-link-open-routing.spec.ts
@@ -1,7 +1,6 @@
import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
import type { AddressInfo } from 'node:net'
import type { Page } from '@stablyai/playwright-test'
-import { parseBrowserNetworkExecutionHostKey } from '../../src/main/browser/browser-network-execution-route'
import { LOCAL_EXECUTION_HOST_ID } from '../../src/shared/execution-host'
import { readOwnedPageUrls } from './helpers/client-hosted-browser-observer'
import {
@@ -16,11 +15,8 @@ import {
} from './helpers/paired-electron-client'
// The link is a dev-server URL on the pane runtime's network, so a client-local fallback would
-// silently load a *different machine's* server. Which machine renders the pixels no longer answers
-// that: under client-hosted placement the guest paints on this desktop while its network is still
-// pinned to the host at creation. So each act below pins the placement it was written for and reads
-// the host's own record — the page row's placement and executionHostKey — instead of inferring
-// routing from where a appeared.
+// silently load a *different machine's* server. Remote-pane links are explicitly server-hosted, so
+// the acts below read the host's own record instead of inferring routing from a .
const PANE_PATH = '/remote-pane'
const LINK_PATH = '/remote-link-target'
@@ -103,56 +99,6 @@ async function readHostServerPlacedBrowserUrls(
return response.result.tabs.filter((tab) => tab.type === 'browser').map((tab) => tab.url ?? '')
}
-type HostBrowserRow = {
- executionHostKey: string | null
- placementKind: string | null
- url: string
-}
-
-/**
- * The host's rows for one URL, asked through the paired client's connection.
- *
- * Why through the client: an Electron peer advertises the client-host capability, so the host
- * answers it with client-placed pages intact and with the placement and network pin it minted at
- * creation. The host still authors every field; the client is only the transport.
- */
-async function readHostBrowserRows(
- page: Page,
- environmentId: string,
- worktreeId: string,
- urlPrefix: string
-): Promise {
- return page.evaluate(
- async ({ environmentId, urlPrefix, worktreeId }) => {
- const response = await window.api.runtimeEnvironments.call({
- selector: environmentId,
- method: 'session.tabs.list',
- params: { worktree: `id:${worktreeId}` },
- timeoutMs: 15_000
- })
- if (!response.ok) {
- throw new Error('host session tab inventory unavailable')
- }
- const { tabs } = response.result as {
- tabs: {
- type: string
- url?: string
- executionHostKey?: string
- placement?: { kind: string }
- }[]
- }
- return tabs
- .filter((tab) => tab.type === 'browser' && (tab.url ?? '').startsWith(urlPrefix))
- .map((tab) => ({
- executionHostKey: tab.executionHostKey ?? null,
- placementKind: tab.placement?.kind ?? null,
- url: tab.url ?? ''
- }))
- },
- { environmentId, urlPrefix, worktreeId }
- )
-}
-
/** Under server placement the client renders nothing itself, so any is a local fallback. */
async function readLocalBrowserViewUrls(page: Page): Promise {
return page.evaluate(() =>
@@ -183,7 +129,6 @@ async function findMirroredPage(
): Promise<{
handleEnvironmentId: string | null
pageId: string
- placementKind: string | null
} | null> {
return page.evaluate(
({ url, worktreeId }) => {
@@ -194,8 +139,7 @@ async function findMirroredPage(
const handle = state?.remoteBrowserPageHandlesByPageId[browserPage.id]
return {
handleEnvironmentId: handle?.environmentId ?? null,
- pageId: browserPage.id,
- placementKind: handle?.placement?.kind ?? null
+ pageId: browserPage.id
}
}
}
@@ -277,7 +221,7 @@ async function openLinkFromRemotePaneContextMenu(page: Page): Promise {
await openInOrca.click()
}
-test('opens a remote pane link on the pane runtime under either placement and refuses to fall back to the client', async ({
+test('opens a remote pane link on the pane runtime and refuses to fall back to the client', async ({
testRepoPath
}, testInfo) => {
test.setTimeout(300_000)
@@ -286,8 +230,7 @@ test('opens a remote pane link on the pane runtime under either placement and re
let client: PairedElectronClient | null = null
try {
- const hostRuntimeId = (await host.client.call('repo.add', { path: testRepoPath, kind: 'git' }))
- ._meta.runtimeId
+ await host.client.call('repo.add', { path: testRepoPath, kind: 'git' })
client = await launchPairedElectronClient(host.offer, testInfo, 'Remote browser link routing')
const page = client.page
const environmentId = client.environmentId
@@ -382,89 +325,65 @@ test('opens a remote pane link on the pane runtime under either placement and re
)
.toBe(0)
await focusMirroredPage(page, worktreeId, pane.pageId)
- const linkLoadsBeforeClientAct = fixture.linkLoadCount()
+ const linkLoadsBeforeSecondAct = fixture.linkLoadCount()
- // Act 2: client-hosted placement, the default. The page is hosted by this desktop, so the
- // proof of correct routing is the host's record of it, not where it painted.
+ // Act 2 still stays server-hosted even when the generic client-hosted preference is enabled:
+ // the remote pane explicitly pins links to its owning runtime.
await pinClientHostedPlacement(page, true)
await openLinkFromRemotePaneContextMenu(page)
- await expect
- .poll(
- async () => (await findMirroredPage(page, worktreeId, fixture.linkUrl))?.placementKind,
- {
- timeout: 60_000,
- message: 'the link never became a client-hosted browser page on this desktop'
- }
- )
- .toBe('client')
- // The host's own connection, unprojected: browser.tabList reads the page registry, which is
- // where a client-hosted page lives.
await expect
.poll(
async () =>
- (await readHostBrowserPageUrls(host.client, worktreeSelector)).filter((url) =>
+ (await readHostServerPlacedBrowserUrls(host, worktreeId)).filter((url) =>
url.startsWith(fixture.linkUrl)
).length,
- { timeout: 60_000, message: 'the link never became a browser page on the host runtime' }
+ {
+ timeout: 60_000,
+ message: 'the owner-pinned link did not stay server-hosted'
+ }
)
.toBe(1)
- const hostRows = await readHostBrowserRows(page, environmentId, worktreeId, fixture.linkUrl)
- expect(hostRows).toHaveLength(1)
- expect(hostRows[0]?.placementKind).toBe('client')
- // The routing invariant, structurally: the host pinned this page's network to its own runtime
- // when it created it, so the dev server was reached through the runtime and not through this
- // machine — which CI cannot tell apart by watching the fixture, since both ends are loopback.
- const executionHostKey = hostRows[0]?.executionHostKey
- if (!executionHostKey) {
- // Narrowed before parsing: an unpinned page would otherwise surface as a parse crash rather
- // than as the missing network pin it is.
- throw new Error('the host minted no network pin for the client-hosted page')
- }
- expect(parseBrowserNetworkExecutionHostKey(executionHostKey)).toMatchObject({
- runtimeId: hostRuntimeId
- })
- expect(fixture.linkLoadCount()).toBeGreaterThan(linkLoadsBeforeClientAct)
- // Hosted here, streamed from nowhere: this desktop holds the page and the runtime holds none.
+ expect(fixture.linkLoadCount()).toBeGreaterThan(linkLoadsBeforeSecondAct)
await expect
- .poll(() => readOwnedPageUrls(client!.app, fixture.linkUrl), {
+ .poll(() => readOwnedPageUrls(host.app, fixture.linkUrl), {
timeout: 60_000,
- message: 'the client-hosted guest never loaded the link on this desktop'
+ message: 'the server-hosted guest never loaded the link on the pane runtime'
})
.toHaveLength(1)
- expect(await readOwnedPageUrls(host.app, fixture.linkUrl)).toHaveLength(0)
- await expect(page.getByTestId('remote-browser-pane')).toHaveCount(paneCountBeforeOpen)
+ expect(await readOwnedPageUrls(client!.app, fixture.linkUrl)).toHaveLength(0)
+ expect(await readLocalBrowserViewUrls(page)).toHaveLength(0)
+ await expect(page.getByTestId('remote-browser-pane')).toHaveCount(paneCountBeforeOpen + 1)
- // The store drops the tab synchronously and only then fires browser.tabClose, so the mirror
- // going empty proves nothing about the host or the guest. Settle both before act 3 baselines
- // them, or act 3 reads this teardown landing mid-act as its own doing.
+ // The store drops the tab synchronously and only then fires browser.tabClose, so settle the
+ // mirror, host inventory, and host guest before act 3 reads them as its own baseline.
await closeBrowserTabsExceptPane(page, worktreeId, fixture.paneUrl)
await expect
.poll(() => findMirroredPage(page, worktreeId, fixture.linkUrl), {
timeout: 60_000,
- message: 'the client kept the closed link tab'
+ message: 'the client kept the closed owner-pinned link tab'
})
.toBeNull()
await expect
.poll(
async () =>
- (await readHostBrowserPageUrls(host.client, worktreeSelector)).filter((url) =>
+ (await readHostServerPlacedBrowserUrls(host, worktreeId)).filter((url) =>
url.startsWith(fixture.linkUrl)
).length,
- { timeout: 60_000, message: 'the runtime kept the closed client-hosted page' }
+ { timeout: 60_000, message: 'the runtime kept the closed server-hosted page' }
)
.toBe(0)
await expect
- .poll(() => readOwnedPageUrls(client!.app, fixture.linkUrl), {
+ .poll(() => readOwnedPageUrls(host.app, fixture.linkUrl), {
timeout: 60_000,
- message: 'the client-hosted guest outlived the tab that owned it'
+ message: 'the server-hosted guest outlived the tab that owned it'
})
.toHaveLength(0)
await focusMirroredPage(page, worktreeId, pane.pageId)
- // Act 3: the user moves this workspace onto their own machine while the runtime's page is
- // still on screen. Opening the link must fail in the pane, not load the runtime's dev server
- // here — the client has no business serving a page for a workspace it does not run.
+ // Act 3: the user moves this workspace onto their own machine. Opening the remote pane link
+ // must fail in the pane, not load the runtime's dev server here — the client has no business
+ // serving a page for a workspace it does not run.
await page.evaluate(
({ localHostId, worktreeId }) => {
window.__store?.getState().setActiveWorktree(worktreeId, localHostId)
From 61e010079f769f40cff39aef09f9788c13c3257d Mon Sep 17 00:00:00 2001
From: Jinjing <6427696+AmethystLiang@users.noreply.github.com>
Date: Wed, 2 Sep 2026 11:00:24 -0700
Subject: [PATCH 05/26] New agent dashboard (#18222)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
* more obvious toggle
* more obvious toggle
* feat(activity): redesign thread rows and add child agent filtering
- Emphasize task title and last activity in row layout over metadata
- Add child agent toggle; hide orchestration workers by default
- Support collapsible groups and ungrouped view mode
- Improve orchestration worker message handling to surface replies
- Add sidebar search and filter controls for agent activity
* periodic checkin
* feat(activity): add "Clear completed" action and performance improvement
- Add "Clear completed" action for activity threads with undo window; clears completed and interrupted rows from view, persists across restart
- Virtualize activity thread list to render only viewport-bounded rows
- Cache activity thread search text to prevent recomputation on every keystroke
- Cache dashboard bucket counts per-worktree for selective invalidation on unrelated changes
- Use useDeferredValue for activity search filtering to keep input responsive
- Make compact mode the default display for activity threads
- Add activity-cleared-at persisted state tracking (per-pane cutoff timestamps)
* improve style
* minor change
* feat(activity): add persisted host and project filters to agents view
Agents scope filters are deliberately separate from workspace-nav filters so a monitoring surface never inherits workspace context silently. Filters survive restarts and always display an active-filter chips row with hidden count, making filtering visible and reversible.
* Graduate Agents view from experimental, refine activity handling
- Agents Dashboard moves from experimental to standard feature with showAgentsSidebar setting controlling visibility
- Add identity-checked cache eviction (dropPersisted IPC) to prevent newer runs from being evicted when UI clears older status, fixing clear-completed safety
- Extract ActivityThreadHoverCardSummary and ActivityThreadListToolbar components for better organization and reusability
- Implement mark-thread-read as separate action from select with clickable bell icon
- Add hasActivityThreadWorkspace helper for checking workspace availability across hosts (SSH/runtime targets)
- Preserve scope filter array identity during hydration for memo optimization
- Track manually-unread turns in auto-ack to prevent re-acknowledgement
- Clean up activity cleared-at cutoffs on pane retirement
- Remove activity-thread-hover-card max-lines lint override (code refactored below threshold)
* Refactor agent cache identity to use timing fields only
- Simplify AgentStatusCacheIdentity: keep only paneKey, receivedAt, stateStartedAt
- This fixes silent no-ops where renderer-enriched fields diverged from main's cache
- Add worktree-jump-navigation for navigating activity to workspaces
- Add manual mark-unread protection separate from auto-ack
- Optimize activity owner resolution with per-build memoization
- Optimize detected worktree lookup with indexed search
* Remove sticky header, add scroll position persistence
Replace the floating sticky header overlay with scroll position memory via
a ref. This preserves the user's scroll location when switching between
threads or remounting the agents list, improving UX without requiring
React state.
* Implement sticky group headers in activity thread list
Keep group headers visible at the top while scrolling when threads are grouped. Headers stick to the viewport while their section is in view, then unstick as the next header approaches.
* add blue flash
* update settings appearnce
* Extracted activity acknowledgement/clearance actions from the oversized UI slice.
- Removed dead sidebar search/menu props and the unused search ref.
- Removed the unnecessary sidebar visibility bitmask.
- Replaced hardcoded sidebar toggle colors with design-system tokens.
- Removed duplicate “mark all read / clear completed” controls in the sidebar.
- Preserved manual-unread state correctly across pane retire, transfer, and drop.
- Made clear-completed cutoffs monotonic so clock skew cannot resurrect old activity.
- Fixed blank workspace names in hover cards with the existing fallback helper.
- Added missing localization entries and stabilized hydrated filter array identity.
- Updated misleading Agents setting copy to describe both sidebar surfaces.
* add onboarding guide for the new agents panel
* Add activity clearance tracking and synced agent view settings
Agent view filters and presentation settings now sync across paired clients.
Preserves per-pane activity clearance cutoffs in persistent state. Improves
activity thread row accessibility with proper ARIA roles, and preserves
terminal host ownership after pane teardown via retained terminal handle.
* rm html
* Graduate Agents from experimental and improve activity visibility
- Migrate `showAgentsSidebar` setting from legacy experimental flags; default new profiles to the agents sidebar
- Replace scoped-thread filtering with visible-thread filtering so bulk actions (mark all read, clear completed) only affect rendered rows
- Rewrite child agent classification as a set of visible pane keys to fix orphan promotion and parent-cycle handling
- Improve activity cleared-at cutoff lifecycle: preserve on row dismissal (pane may still be live) but clear on pane removal
- Add pagehide flush for pending clear-completed evictions so quit/reload cannot replay cleared activity
- Polish agents sidebar: unread count badge, expand button, onboarding intro for migrated/new users
- Extract shared time-ago formatting to a library module
- Fix scroll restoration to defer until content can contain the saved offset
- Improve stable message hold for compact agent rows using state instead of refs
- Add worktree filter-visibility check to distinguish collapsed-but-unfiltered from filtered-hidden
* Graduate Agents from experimental and improve activity visibility
- Remove the deprecated full-page Agents view; fix settings navigation fallback
- Refactor bulk action bindings and separate mark-all-read from visible threads
- Preserve sidebar collapse state across remounts; fix child-agent badge filtering
- Add safety window for scroll-restore and improve worktree host-qualified filtering
* Graduate Agents from experimental and add manual unread tracking
- Move Agents sidebar from experimental settings to standard feature with intro flow
- Add persistent manual unread turn tracking for activity feed
- Consolidate workspace activation through activateAndRevealWorkspace dispatcher
- Improve sidebar view toggle with radio semantics and arrow-key navigation
* Graduate Agents sidebar and separate dashboard experiment
The Agents tab now has its own `showAgentsSidebar` setting (defaults on) independent from the dashboard popout experiment. Activity unread counting is simplified to count all events uniformly without mode-specific filtering. Dashboard visibility is now controlled solely by `experimentalAgentDashboardPopout`, with its own UI in the Experimental settings pane. Migration path updated: only `experimentalActivity=true` graduates to the sidebar; the dashboard experiment remains separate.
* Add agent-session tab support to activity tracking
Build activity event contexts from structured agent-session tabs and
worktree-attributed status entries. When activating a thread, try
agent-session tab activation before falling back to terminal pane.
* • The workspace sidebar tab is now a static Spaces
label—no grouping-based “Projects” label or hidden
width-reservation span.
* Show unread count badge and prioritize attention-needing agent threads
Activity group order now surfaces threads needing attention (blocked,
waiting, interrupted) before working/done so they're never buried. The
Agents tab shows an unread count badge while viewing Spaces, since the
open Agents list already highlights unread rows.
Also improves UX text ("Hide Agents" vs "Maybe later"), accessibility
with proper ARIA labels, and handles edge cases: preserves read state
for retained panes on SSH reconnect and handles deleted worktrees
gracefully in navigation.
* Batch agent-status evictions and optimize activity pane rebuilds
- Add dropPersistedStatusEntries batch API; consolidate evictions into one persist
- Implement fallback timeout in clear-completed for unseen toast callbacks
- Project only activity-relevant tabs; memoize terminal tab derivations
- Stabilize activity virtualizer key to prevent unnecessary item measurements
* Remove unread count badge from Agents sidebar tab
Simplify useActivityUnreadCount by removing the enabled parameter and
conditional logic, as the badge is no longer displayed in the UI.
* Deduplicate activity unread counts across source overlaps
Live pane status is the primary source; retained and migration entries
serve as fallback caches that may briefly overlap it during lifecycle
transitions. Count each pane only once by tracking seen keys, prioritizing
the live status as the canonical source.
Also fix monitoring state display: it's a distinct agent state, not a
tool-running row state, so exclude it from tool preview checks.
* Update activity pane tests to remove unread badge assertions
- Remove ActivityPaneVisibility type and readActivityPaneVisibility() helper
- Update agentsSidebarButton selector to match badge-less state
- Simplify assertions to check pane focus instead of visibility isolation
- Remove test for unread badge acknowledgement flow
* Fix activity pane workspace resolution and localization handling
- Thread defaultHostId through activity operations for correct host resolution
- Add language-aware caching for standalone terminal names with cache invalidation
- Fix scroll restoration bounds calculation for tall viewports
- Add focus management to sidebar radio group keyboard navigation
- Refresh localized sidebar content on language changes
- Preserve activity state across heartbeats to prevent history loss
- Improve host-id strictness in worktree jump navigation
* Preserve activity view when settings fetch fails
A failed window.api.settings.get() leaves settings null, which was
incorrectly treated as opt-out. Add the missing null check so the
activity-view gate only applies when settings are available.
Includes tests for this scenario and related edge cases in keyboard
navigation, worktree jumping, and session state handling.
---
docs/reference/wsl-probe-failure-semantics.md | 10 +-
.../server-status-listener-fanout.test.ts | 138 +++++
src/main/agent-hooks/server/server-cleanup.ts | 46 ++
src/main/ipc/agent-hooks.test.ts | 72 +++
src/main/ipc/agent-status-row-teardown-ipc.ts | 53 +-
.../applying-settings/ui-state-read.ts | 1 +
.../applying-settings/ui-state-update.ts | 4 +
.../normalize-loaded-global-settings.test.ts | 80 +++
.../normalize-loaded-global-settings.ts | 11 +
.../workspace-session-snapshot-publication.ts | 26 +-
.../pane-key-remapping.test.ts | 33 ++
.../restoring-sessions/pane-key-remapping.ts | 75 +++
.../workspace-pane-normalization.ts | 86 ++--
.../client-ui-pairing-local-fields.test.ts | 8 +-
.../runtime/rpc/methods/client-ui-schemas.ts | 6 +
src/preload/api/agent-status-api.ts | 5 +
src/preload/api/agent-status-bridge.ts | 7 +
.../app-shell/use-app-startup-hydration.ts | 10 +
.../src/app-shell/use-persisted-ui-writer.ts | 6 +-
.../activity/ActivityPrototypePage.test.ts | 44 +-
...ivityPrototypePage.thread-grouping.test.ts | 13 +
.../activity/ActivityPrototypePage.tsx | 160 +++---
.../ActivityThreadOptionsMenu.test.tsx | 150 ++++++
.../activity/ActivityTitlebarControls.tsx | 2 +-
...vity-auto-mark-read-loop.react185.test.tsx | 2 +-
.../activity/activity-clear-completed.test.ts | 362 +++++++++++++
.../activity/activity-clear-completed.ts | 206 ++++++++
.../activity/activity-event-build-cache.ts | 129 +++++
...tivity-event-builder-agent-context.test.ts | 165 ++++++
.../activity-event-builder-context.ts | 182 +++++++
.../activity-event-builder-sources.ts | 105 ++++
...vity-event-builder.bounded-history.test.ts | 122 +++++
...ivity-event-builder.host-ownership.test.ts | 206 ++++++++
...ivity-event-builder.identity-reuse.test.ts | 225 ++++++++
.../activity/activity-event-builder.ts | 306 ++++-------
.../components/activity/activity-event-cap.ts | 3 +-
.../activity/activity-pane-events.ts | 108 ++++
.../activity-scope-filter-controls.tsx | 170 ++++++
.../activity/activity-scope-filter.test.ts | 130 +++++
.../activity/activity-scope-filter.ts | 80 +++
.../activity/activity-standalone-worktree.ts | 67 +++
.../activity/activity-tab-projection.ts | 66 +++
.../activity/activity-thread-actions.test.ts | 162 ++++++
.../activity/activity-thread-actions.ts | 101 +++-
.../activity/activity-thread-builder.ts | 89 +++-
.../activity-thread-child-agent.test.ts | 171 +++++++
.../activity/activity-thread-child-agent.ts | 90 ++++
.../activity-thread-collapse-context.ts | 13 +
.../activity/activity-thread-controls.tsx | 130 +++--
...ivity-thread-grouping.search-cache.test.ts | 53 ++
.../activity/activity-thread-grouping.ts | 41 +-
.../activity-thread-hover-card-summary.tsx | 230 +++++++++
.../activity-thread-hover-card.test.tsx | 238 +++++++++
.../activity/activity-thread-hover-card.tsx | 407 +++++++++++++++
...vity-thread-list-pane-collapsible.test.tsx | 292 +++++++++++
.../activity/activity-thread-list-pane.tsx | 484 ++++++++++++------
...y-thread-list-pane.virtualization.test.tsx | 237 +++++++++
.../activity-thread-list-resize-handle.tsx | 37 ++
.../activity/activity-thread-list-toolbar.tsx | 227 ++++++++
.../activity/activity-thread-options-menu.tsx | 291 +++++++++++
.../activity-thread-presentation.test.ts | 97 ++++
.../activity/activity-thread-presentation.ts | 60 ++-
.../activity/activity-thread-row.tsx | 318 ++++++------
.../activity/activity-thread-types.ts | 2 +-
.../activity-thread-virtual-items.test.ts | 82 +++
.../activity/activity-thread-virtual-items.ts | 74 +++
.../activity/activity-thread-virtual-row.tsx | 71 +++
.../activity/dev-activity-fixture.test.ts | 39 ++
.../activity/dev-activity-fixture.ts | 127 +++++
.../event-time-clock-refresh.test.tsx | 54 ++
...e-activity-thread-action-bindings.test.tsx | 113 ++++
.../use-activity-thread-action-bindings.ts | 71 +++
.../activity/use-agent-pane-threads.ts | 264 ++++++++++
.../activity/useActivityUnreadCount.test.ts | 69 ++-
.../activity/useActivityUnreadCount.ts | 130 ++---
.../dashboard/agent-row-lineage-model.ts | 17 +-
...uild-dashboard-bucket-counts.cache.test.ts | 190 +++++++
.../build-dashboard-bucket-counts.ts | 86 ++--
...uild-dashboard-snapshot.rows-cache.test.ts | 142 +++++
.../dashboard/build-dashboard-snapshot.ts | 75 ++-
.../dashboard/useAgentBucketCounts.test.tsx | 11 +-
.../dashboard/useAgentBucketCounts.ts | 16 +-
.../dashboard/useDashboardPopoutBridge.ts | 10 +-
.../dashboard/useLiveDashboardSnapshot.ts | 9 +-
.../dashboard/worktree-agent-rows-cache.ts | 181 +++++++
.../AppearanceWindowSidebarSection.tsx | 2 -
.../settings/ExperimentalPane.test.tsx | 19 +-
.../components/settings/ExperimentalPane.tsx | 83 ++-
.../settings/appearance-sidebar-search.ts | 21 +
.../settings/experimental-search.ts | 61 +--
.../sidebar/AgentDashboardSidebarEntry.tsx | 5 +-
.../src/components/sidebar/Sidebar.test.tsx | 69 ++-
.../components/sidebar/SidebarAgentsList.tsx | 144 ++++++
.../components/sidebar/SidebarHeader.test.tsx | 339 +++++++++++-
.../src/components/sidebar/SidebarHeader.tsx | 263 +++++++---
.../components/sidebar/SidebarNav.test.tsx | 35 +-
.../src/components/sidebar/SidebarNav.tsx | 71 +--
.../SidebarRepositoryFilterSection.tsx | 14 +-
.../sidebar/SidebarWorkspaceOptionsMenu.tsx | 223 +-------
.../sidebar/agents-sidebar-visibility.test.ts | 15 +
.../sidebar/agents-sidebar-visibility.ts | 11 +
src/renderer/src/components/sidebar/index.tsx | 209 +++++++-
.../sidebar/sidebar-count-badge.tsx | 24 +
.../sidebar/sidebar-header-actions.tsx | 194 +++++++
.../sidebar/sidebar-view-toggle.test.tsx | 145 ++++++
.../sidebar/sidebar-view-toggle.tsx | 106 ++++
...se-workspace-reveal-body-redirect.test.tsx | 77 +++
.../use-workspace-reveal-body-redirect.ts | 43 ++
.../components/sidebar/visible-worktrees.ts | 69 +--
.../sidebar/workspace-options-menu-items.tsx | 240 +++++++++
.../sidebar/worktree-agent-row-selectors.ts | 12 +
...-compact-agent-row.stable-message.test.tsx | 112 ++++
.../worktree-card-compact-agent-row.tsx | 49 +-
.../worktree-filter-visibility.test.ts | 79 +++
.../sidebar/worktree-filter-visibility.ts | 43 ++
.../terminal-pane/stale-agent-row.ts | 2 +-
.../use-terminal-pane-close-actions.ts | 2 +-
.../src/components/ui/dropdown-menu.tsx | 2 +-
src/renderer/src/components/ui/popover.tsx | 17 +-
.../useAutoAckViewedAgent.clock-skew.test.ts | 10 +
.../src/hooks/useAutoAckViewedAgent.test.ts | 45 ++
.../src/hooks/useAutoAckViewedAgent.ts | 66 ++-
src/renderer/src/i18n/locales/en.json | 70 ++-
src/renderer/src/i18n/locales/es.json | 29 +-
src/renderer/src/i18n/locales/ja.json | 29 +-
src/renderer/src/i18n/locales/ko.json | 52 +-
src/renderer/src/i18n/locales/zh.json | 52 +-
.../src/lib/activity-thread-display.test.ts | 79 +++
.../src/lib/activity-thread-display.ts | 64 ++-
src/renderer/src/lib/short-time-ago.ts | 16 +
src/renderer/src/lib/worktree-activation.ts | 43 +-
.../src/lib/worktree-jump-navigation.test.ts | 151 ++++++
.../src/lib/worktree-jump-navigation.ts | 95 ++++
.../src/lib/worktree-runtime-owner-index.ts | 9 +-
.../agent-status-primitives.ts | 8 +-
.../runtime/web-session-tabs-sync/state.ts | 2 +
.../store/slices/activity-cleared-at.test.ts | 169 ++++++
.../store/slices/agent-pane-authority.test.ts | 14 +
.../slices/agent-status-ack-cleanup.test.ts | 61 +++
.../slices/agent-status-authority-actions.ts | 10 +
.../slices/agent-status-cleanup-actions.ts | 52 +-
.../src/store/slices/agent-status-contract.ts | 10 +
.../store/slices/agent-status-drop-actions.ts | 58 ++-
.../store/slices/agent-status-drop-reducer.ts | 35 +-
.../slices/agent-status-pane-keyed-records.ts | 12 +
.../agent-status-provider-session-actions.ts | 10 +-
.../agent-status-provider-session.test.ts | 40 ++
.../slices/agent-status-retention-actions.ts | 30 ++
.../slices/agent-status-slice-contract.ts | 6 +-
.../agent-status-worktree-drop-actions.ts | 52 +-
.../persisted-ui-write-baseline.test.ts | 24 +
.../slices/persisted-ui-write-baseline.ts | 13 +-
.../retired-terminal-tab-state-sweep.ts | 8 +-
.../store/slices/runtime-status-recheck.ts | 5 +-
.../slices/ui-hydration-view-layout.test.ts | 35 +-
...ui-hydration-workspace-preferences.test.ts | 118 +++++
.../store/slices/ui-page-navigation.test.ts | 29 ++
.../slices/ui/ui-slice-activity-actions.ts | 155 ++++++
.../store/slices/ui/ui-slice-agent-actions.ts | 105 +---
.../store/slices/ui/ui-slice-contract-core.ts | 6 +
.../ui/ui-slice-contract-preferences.ts | 12 +
.../slices/ui/ui-slice-hydration-actions.ts | 94 ++--
.../ui/ui-slice-hydration-sanitizers.ts | 40 +-
.../slices/ui/ui-slice-hydration-values.ts | 22 +
.../slices/ui/ui-slice-preference-actions.ts | 25 +
.../slices/ui/ui-slice-settings-actions.ts | 5 +-
.../slices/ui/ui-slice-surface-actions.ts | 4 +
.../store/slices/ui/ui-slice-view-actions.ts | 6 +-
.../listing/detected-worktree-meta.ts | 30 +-
.../teardown/worktree-purge-state.ts | 2 +
.../web/preload-api/web-agent-status-api.ts | 2 +
.../web-preference-normalization.ts | 8 +-
.../src/web/web-preload-api-ui.test.ts | 16 +-
src/shared/agent-status-ipc-payload.ts | 10 +
src/shared/agent-status-types.ts | 1 +
src/shared/agents-sidebar-visibility.ts | 12 +
src/shared/constants.ts | 6 +
src/shared/default-global-settings.ts | 1 +
src/shared/global-settings-types.ts | 6 +
src/shared/pairing-local-ui-fields.test.ts | 8 +-
src/shared/pairing-local-ui-fields.ts | 9 +-
src/shared/persisted-ui-state-types.ts | 12 +
src/shared/telemetry-property-schemas.ts | 1 +
.../e2e/activity-agent-pane-isolation.spec.ts | 129 +----
184 files changed, 12459 insertions(+), 1960 deletions(-)
create mode 100644 src/main/persistence/loading-store/normalize-loaded-global-settings.test.ts
create mode 100644 src/main/persistence/restoring-sessions/pane-key-remapping.test.ts
create mode 100644 src/main/persistence/restoring-sessions/pane-key-remapping.ts
create mode 100644 src/renderer/src/components/activity/activity-clear-completed.test.ts
create mode 100644 src/renderer/src/components/activity/activity-clear-completed.ts
create mode 100644 src/renderer/src/components/activity/activity-event-build-cache.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder-agent-context.test.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder-context.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder-sources.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder.bounded-history.test.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder.host-ownership.test.ts
create mode 100644 src/renderer/src/components/activity/activity-event-builder.identity-reuse.test.ts
create mode 100644 src/renderer/src/components/activity/activity-pane-events.ts
create mode 100644 src/renderer/src/components/activity/activity-scope-filter-controls.tsx
create mode 100644 src/renderer/src/components/activity/activity-scope-filter.test.ts
create mode 100644 src/renderer/src/components/activity/activity-scope-filter.ts
create mode 100644 src/renderer/src/components/activity/activity-standalone-worktree.ts
create mode 100644 src/renderer/src/components/activity/activity-tab-projection.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-actions.test.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-child-agent.test.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-child-agent.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-collapse-context.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-grouping.search-cache.test.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-hover-card-summary.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-hover-card.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-list-pane-collapsible.test.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-list-pane.virtualization.test.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-list-resize-handle.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-list-toolbar.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-options-menu.tsx
create mode 100644 src/renderer/src/components/activity/activity-thread-presentation.test.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-virtual-items.test.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-virtual-items.ts
create mode 100644 src/renderer/src/components/activity/activity-thread-virtual-row.tsx
create mode 100644 src/renderer/src/components/activity/dev-activity-fixture.test.ts
create mode 100644 src/renderer/src/components/activity/dev-activity-fixture.ts
create mode 100644 src/renderer/src/components/activity/event-time-clock-refresh.test.tsx
create mode 100644 src/renderer/src/components/activity/use-activity-thread-action-bindings.test.tsx
create mode 100644 src/renderer/src/components/activity/use-activity-thread-action-bindings.ts
create mode 100644 src/renderer/src/components/activity/use-agent-pane-threads.ts
create mode 100644 src/renderer/src/components/dashboard/build-dashboard-bucket-counts.cache.test.ts
create mode 100644 src/renderer/src/components/dashboard/build-dashboard-snapshot.rows-cache.test.ts
create mode 100644 src/renderer/src/components/dashboard/worktree-agent-rows-cache.ts
create mode 100644 src/renderer/src/components/sidebar/SidebarAgentsList.tsx
create mode 100644 src/renderer/src/components/sidebar/agents-sidebar-visibility.test.ts
create mode 100644 src/renderer/src/components/sidebar/agents-sidebar-visibility.ts
create mode 100644 src/renderer/src/components/sidebar/sidebar-count-badge.tsx
create mode 100644 src/renderer/src/components/sidebar/sidebar-header-actions.tsx
create mode 100644 src/renderer/src/components/sidebar/sidebar-view-toggle.test.tsx
create mode 100644 src/renderer/src/components/sidebar/sidebar-view-toggle.tsx
create mode 100644 src/renderer/src/components/sidebar/use-workspace-reveal-body-redirect.test.tsx
create mode 100644 src/renderer/src/components/sidebar/use-workspace-reveal-body-redirect.ts
create mode 100644 src/renderer/src/components/sidebar/workspace-options-menu-items.tsx
create mode 100644 src/renderer/src/components/sidebar/worktree-card-compact-agent-row.stable-message.test.tsx
create mode 100644 src/renderer/src/components/sidebar/worktree-filter-visibility.test.ts
create mode 100644 src/renderer/src/components/sidebar/worktree-filter-visibility.ts
create mode 100644 src/renderer/src/lib/short-time-ago.ts
create mode 100644 src/renderer/src/lib/worktree-jump-navigation.test.ts
create mode 100644 src/renderer/src/lib/worktree-jump-navigation.ts
create mode 100644 src/renderer/src/store/slices/activity-cleared-at.test.ts
create mode 100644 src/renderer/src/store/slices/ui/ui-slice-activity-actions.ts
create mode 100644 src/shared/agents-sidebar-visibility.ts
diff --git a/docs/reference/wsl-probe-failure-semantics.md b/docs/reference/wsl-probe-failure-semantics.md
index cadcbf53364..dcaa67a5d4d 100644
--- a/docs/reference/wsl-probe-failure-semantics.md
+++ b/docs/reference/wsl-probe-failure-semantics.md
@@ -35,11 +35,11 @@ silent, and indistinguishable from the real thing.
Three instances so far:
-| Where | What the user saw | Status |
-| --- | --- | --- |
-| Preflight CLI probes | Caching the result would have pinned "git not installed" until relaunch | Bounded entry ([#17350](https://github.com/stablyai/orca/pull/17350)) |
-| `glab auth status` fallback into WSL | Idle VM woken repeatedly for users who never touch GitLab | Open ([#8941](https://github.com/stablyai/orca/issues/8941)) |
-| `listRunningWslDistrosAsync` | Fails closed to `[]` with no last-known-good, polled every 2s — a persistently broken `wsl.exe` makes every WSL session vanish app-wide | Open (PR #17072 review) |
+| Where | What the user saw | Status |
+| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| Preflight CLI probes | Caching the result would have pinned "git not installed" until relaunch | Bounded entry ([#17350](https://github.com/stablyai/orca/pull/17350)) |
+| `glab auth status` fallback into WSL | Idle VM woken repeatedly for users who never touch GitLab | Open ([#8941](https://github.com/stablyai/orca/issues/8941)) |
+| `listRunningWslDistrosAsync` | Fails closed to `[]` with no last-known-good, polled every 2s — a persistently broken `wsl.exe` makes every WSL session vanish app-wide | Open (PR #17072 review) |
## What to do instead
diff --git a/src/main/agent-hooks/server-status-listener-fanout.test.ts b/src/main/agent-hooks/server-status-listener-fanout.test.ts
index 9f977672239..b6633dbf6f1 100644
--- a/src/main/agent-hooks/server-status-listener-fanout.test.ts
+++ b/src/main/agent-hooks/server-status-listener-fanout.test.ts
@@ -205,6 +205,144 @@ describe('AgentHookServer listener replay', () => {
expect(listener).toHaveBeenNthCalledWith(4, [])
})
+ it('evicts only the matching persisted status identity', () => {
+ const server = new AgentHookServer()
+ server.ingestRemote(
+ {
+ paneKey: PANE,
+ tabId: 'tab-1',
+ worktreeId: 'wt-1',
+ providerSession: { key: 'session_id', id: 'resume-me' },
+ payload: { state: 'done', prompt: 'old run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ const old = server.getStatusSnapshot()[0]
+ expect(old).toBeDefined()
+
+ server.ingestRemote(
+ {
+ paneKey: PANE,
+ tabId: 'tab-1',
+ worktreeId: 'wt-1',
+ payload: { state: 'working', prompt: 'new run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ server.dropPersistedStatusEntry({
+ paneKey: old!.paneKey,
+ receivedAt: old!.receivedAt,
+ stateStartedAt: old!.stateStartedAt
+ })
+
+ expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'working', prompt: 'new run' })
+
+ // A matching eviction follows ordinary dismissal semantics, including
+ // preserving a resumable provider session for the still-live TUI.
+ const resumed = new AgentHookServer()
+ resumed.ingestRemote(
+ {
+ paneKey: PANE,
+ tabId: 'tab-1',
+ worktreeId: 'wt-1',
+ providerSession: { key: 'session_id', id: 'resume-me' },
+ payload: { state: 'done', prompt: 'old run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ const resumedIdentity = resumed.getStatusSnapshot()[0]!
+ expect(
+ resumed.dropPersistedStatusEntry({
+ paneKey: resumedIdentity.paneKey,
+ receivedAt: resumedIdentity.receivedAt,
+ stateStartedAt: resumedIdentity.stateStartedAt
+ })
+ ).toBe(true)
+ expect(resumed.getStatusSnapshot()[0]).toMatchObject({
+ providerSessionOnly: true,
+ providerSession: { id: 'resume-me' }
+ })
+ })
+
+ it('evicts when the renderer identity was stamped after receipt but pins the same turn', () => {
+ // Runtime-sync and recovery entries stamp updatedAt with Date.now()/capturedAt, which is
+ // at or after main's receivedAt; the eviction must still land for those rows.
+ const server = new AgentHookServer()
+ server.ingestRemote(
+ {
+ paneKey: PANE,
+ tabId: 'tab-1',
+ worktreeId: 'wt-1',
+ payload: { state: 'done', prompt: 'run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ const entry = server.getStatusSnapshot()[0]!
+ expect(
+ server.dropPersistedStatusEntry({
+ paneKey: entry.paneKey,
+ receivedAt: entry.receivedAt + 5_000,
+ stateStartedAt: entry.stateStartedAt
+ })
+ ).toBe(true)
+
+ // A different turn never matches, whatever the receivedAt relationship.
+ const other = new AgentHookServer()
+ other.ingestRemote(
+ {
+ paneKey: PANE,
+ tabId: 'tab-1',
+ worktreeId: 'wt-1',
+ payload: { state: 'done', prompt: 'run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ const otherEntry = other.getStatusSnapshot()[0]!
+ expect(
+ other.dropPersistedStatusEntry({
+ paneKey: otherEntry.paneKey,
+ receivedAt: otherEntry.receivedAt + 5_000,
+ stateStartedAt: otherEntry.stateStartedAt + 1
+ })
+ ).toBe(false)
+ })
+
+ it('evicts a batch of persisted identities with one status-change notification', () => {
+ const server = new AgentHookServer()
+ const otherPane = makePaneKey('tab-2', '22222222-2222-4222-8222-222222222222')
+ for (const paneKey of [PANE, otherPane]) {
+ server.ingestRemote(
+ {
+ paneKey,
+ tabId: paneKey.split(':')[0]!,
+ worktreeId: 'wt-1',
+ payload: { state: 'done', prompt: 'run', agentType: 'claude' }
+ },
+ 'conn-1'
+ )
+ }
+ const listener = vi.fn()
+ server.subscribeStatusChanges(listener)
+ const dropped: string[] = []
+ server.subscribeStatusDrop((paneKey) => dropped.push(paneKey))
+ const identities = server.getStatusSnapshot().map((entry) => ({
+ paneKey: entry.paneKey,
+ receivedAt: entry.receivedAt,
+ stateStartedAt: entry.stateStartedAt
+ }))
+
+ const evicted = server.dropPersistedStatusEntries([
+ ...identities,
+ // A stale identity never matches and never blocks the rest of the batch.
+ { ...identities[0]!, stateStartedAt: identities[0]!.stateStartedAt + 1 }
+ ])
+
+ expect(evicted.sort()).toEqual([PANE, otherPane].sort())
+ expect(dropped.sort()).toEqual([PANE, otherPane].sort())
+ expect(listener).toHaveBeenCalledTimes(1)
+ expect(server.getStatusSnapshot()).toEqual([])
+ })
+
it('notifies pane-status-clear listener when pane teardown evicts a cached status', () => {
const server = new AgentHookServer()
const listener = vi.fn()
diff --git a/src/main/agent-hooks/server/server-cleanup.ts b/src/main/agent-hooks/server/server-cleanup.ts
index 04acc058dea..4fcd0b5e58e 100644
--- a/src/main/agent-hooks/server/server-cleanup.ts
+++ b/src/main/agent-hooks/server/server-cleanup.ts
@@ -1,4 +1,5 @@
import { paneHasStateClaims } from '../../../shared/agent-hook-listener/listener-state'
+import type { AgentStatusCacheIdentity } from '../../../shared/agent-status-types'
import type { EnrichedAgentHookEventPayload } from './server-types'
import { AgentHookServerAuthorityFences } from './server-authority-fences'
@@ -35,6 +36,51 @@ export abstract class AgentHookServerCleanup extends AgentHookServerAuthorityFen
this.emitStatusDropped(deleted.paneKey)
}
+ /** Evict a UI-cleared status only if no newer status has replaced it. */
+ dropPersistedStatusEntry(identity: AgentStatusCacheIdentity): boolean {
+ return this.dropPersistedStatusEntries([identity]).length > 0
+ }
+
+ /** Batch form: one persist and one listener notification for the whole set. Returns the
+ * pane keys that were actually evicted. */
+ dropPersistedStatusEntries(identities: readonly AgentStatusCacheIdentity[]): string[] {
+ const evicted: string[] = []
+ for (const identity of identities) {
+ const resolvedPaneKey = this.resolvePaneKeyAlias(identity.paneKey)
+ const existing = this.state.lastStatusByPaneKey.get(resolvedPaneKey) as
+ | EnrichedAgentHookEventPayload
+ | undefined
+ // Why: stateStartedAt pins the turn; the renderer's updatedAt is stamped at or after this
+ // receivedAt (runtime-sync and recovery paths use Date.now()/capturedAt), so a strictly
+ // newer cached event is the only replacement worth protecting.
+ if (
+ !existing ||
+ existing.stateStartedAt !== identity.stateStartedAt ||
+ existing.receivedAt > identity.receivedAt
+ ) {
+ continue
+ }
+ const deleted = this.deleteStatusEntry(resolvedPaneKey, { preserveAuthority: true })
+ if (!deleted) {
+ continue
+ }
+ const retained = this.toRetainedProviderSessionRow(deleted)
+ if (retained) {
+ this.state.lastStatusByPaneKey.set(deleted.paneKey, retained)
+ }
+ evicted.push(deleted.paneKey)
+ }
+ if (evicted.length === 0) {
+ return evicted
+ }
+ this.scheduleStatusPersist()
+ this.notifyStatusChangeListeners()
+ for (const paneKey of evicted) {
+ this.emitStatusDropped(paneKey)
+ }
+ return evicted
+ }
+
/** Retire panes whose owning process is certifiably dead.
*
* The ordinary teardown already does this: every attributable PTY exit reaches
diff --git a/src/main/ipc/agent-hooks.test.ts b/src/main/ipc/agent-hooks.test.ts
index e9e7a728e83..cd6c21526d8 100644
--- a/src/main/ipc/agent-hooks.test.ts
+++ b/src/main/ipc/agent-hooks.test.ts
@@ -8,6 +8,8 @@ import { makePaneKey } from '../../shared/stable-pane-id'
// evicts the entry.
const dropStatusEntry = vi.fn()
+const dropPersistedStatusEntry = vi.fn()
+const dropPersistedStatusEntries = vi.fn(() => [] as string[])
const dropStatusEntriesByTabPrefix = vi.fn()
const retirePaneAuthority = vi.fn()
const transferPaneAuthority = vi.fn()
@@ -44,6 +46,8 @@ vi.mock('../agent-hooks/server', async () => {
...actual,
agentHookServer: {
dropStatusEntry,
+ dropPersistedStatusEntry,
+ dropPersistedStatusEntries,
dropStatusEntriesByTabPrefix,
retirePaneAuthority,
transferPaneAuthority,
@@ -105,6 +109,9 @@ vi.mock('../kimi/hook-service', () => ({
beforeEach(() => {
dropStatusEntry.mockReset()
+ dropPersistedStatusEntry.mockReset()
+ dropPersistedStatusEntries.mockReset()
+ dropPersistedStatusEntries.mockReturnValue([])
dropStatusEntriesByTabPrefix.mockReset()
retirePaneAuthority.mockReset()
transferPaneAuthority.mockReset()
@@ -279,6 +286,71 @@ describe('agentStatus:drop IPC', () => {
})
})
+describe('agentStatus:dropPersisted IPC', () => {
+ it('forwards a validated cache identity without clearing pane state', async () => {
+ const { registerAgentHookHandlers } = await import('./agent-hooks')
+ registerAgentHookHandlers()
+
+ const handler = onHandlers.get('agentStatus:dropPersisted')
+ expect(handler).toBeDefined()
+ const identity = {
+ paneKey: PANE_KEY,
+ receivedAt: 2_000,
+ stateStartedAt: 1_000
+ }
+ handler!({}, identity)
+ expect(dropPersistedStatusEntry).toHaveBeenCalledWith(identity)
+ expect(dropStatusEntry).not.toHaveBeenCalled()
+ })
+
+ it('forwards a batch, keeping only valid identities, and clears migration state per evicted pane', async () => {
+ const { registerAgentHookHandlers } = await import('./agent-hooks')
+ registerAgentHookHandlers()
+
+ const handler = onHandlers.get('agentStatus:dropPersistedBatch')
+ expect(handler).toBeDefined()
+ const good = { paneKey: PANE_KEY, receivedAt: 2_000, stateStartedAt: 1_000 }
+ const alsoGood = { paneKey: CHILD_PANE_KEY, receivedAt: 3_000, stateStartedAt: 2_500 }
+ dropPersistedStatusEntries.mockReturnValue([PANE_KEY])
+ handler!({}, [good, { paneKey: 'not-a-pane-key', receivedAt: 1, stateStartedAt: 1 }, alsoGood])
+ expect(dropPersistedStatusEntries).toHaveBeenCalledWith([good, alsoGood])
+ expect(clearMigrationUnsupportedPtysForPaneKey).toHaveBeenCalledWith(PANE_KEY)
+ expect(clearMigrationUnsupportedPtysForPaneKey).not.toHaveBeenCalledWith(CHILD_PANE_KEY)
+ expect(dropPersistedStatusEntry).not.toHaveBeenCalled()
+ })
+
+ it('ignores a batch that is not an array or is empty after validation', async () => {
+ const { registerAgentHookHandlers } = await import('./agent-hooks')
+ registerAgentHookHandlers()
+
+ const handler = onHandlers.get('agentStatus:dropPersistedBatch')!
+ for (const value of [null, {}, 'x', [], [{ paneKey: PANE_KEY }]]) {
+ expect(() => handler({}, value)).not.toThrow()
+ }
+ expect(dropPersistedStatusEntries).not.toHaveBeenCalled()
+ })
+
+ it('rejects malformed cache identities', async () => {
+ const { registerAgentHookHandlers } = await import('./agent-hooks')
+ registerAgentHookHandlers()
+
+ const handler = onHandlers.get('agentStatus:dropPersisted')!
+ for (const value of [
+ null,
+ undefined,
+ {},
+ { paneKey: PANE_KEY },
+ { paneKey: PANE_KEY, receivedAt: Number.NaN, stateStartedAt: 1 },
+ { paneKey: PANE_KEY, receivedAt: 2, stateStartedAt: Number.POSITIVE_INFINITY },
+ { paneKey: 'not-a-pane-key', receivedAt: 2, stateStartedAt: 1 },
+ { paneKey: PANE_KEY, receivedAt: '2', stateStartedAt: 1 }
+ ]) {
+ expect(() => handler({}, value)).not.toThrow()
+ }
+ expect(dropPersistedStatusEntry).not.toHaveBeenCalled()
+ })
+})
+
describe('agentStatus:dropByTabPrefix IPC', () => {
it('forwards valid tab ids to tab-prefix cache eviction', async () => {
const { registerAgentHookHandlers } = await import('./agent-hooks')
diff --git a/src/main/ipc/agent-status-row-teardown-ipc.ts b/src/main/ipc/agent-status-row-teardown-ipc.ts
index e33e1c93789..020cfa7259d 100644
--- a/src/main/ipc/agent-status-row-teardown-ipc.ts
+++ b/src/main/ipc/agent-status-row-teardown-ipc.ts
@@ -1,5 +1,6 @@
import { ipcMain } from 'electron'
import { agentHookServer, isValidPaneKey } from '../agent-hooks/server'
+import type { AgentStatusCacheIdentity } from '../../shared/agent-status-types'
import {
clearMigrationUnsupportedPtysByTabPrefix,
clearMigrationUnsupportedPtysForPaneKey
@@ -7,7 +8,7 @@ import {
import { isValidAgentStatusDropTabId } from './agent-status-ipc-boundary'
/**
- * The three renderer-initiated ways a status row goes away. All fire-and-forget
+ * The renderer-initiated ways a status row goes away. All fire-and-forget
* (`ipcRenderer.send` → `ipcMain.on`), so none round-trips a response; removing the
* listeners first keeps re-registration safe.
*
@@ -15,8 +16,13 @@ import { isValidAgentStatusDropTabId } from './agent-status-ipc-boundary'
* still be alive; a confirmed process exit must take them too, or a surviving Claude latch resolves
* the pane's next event straight back to `working`.
*/
+// Why a cap: the renderer sends one batch per Clear-completed click, bounded by visible rows.
+const MAX_DROP_PERSISTED_BATCH = 5_000
+
export function registerAgentStatusRowTeardownIpcHandlers(): void {
ipcMain.removeAllListeners('agentStatus:drop')
+ ipcMain.removeAllListeners('agentStatus:dropPersisted')
+ ipcMain.removeAllListeners('agentStatus:dropPersistedBatch')
ipcMain.removeAllListeners('agentStatus:reconcileEndedProcess')
ipcMain.removeAllListeners('agentStatus:dropByTabPrefix')
@@ -36,6 +42,36 @@ export function registerAgentStatusRowTeardownIpcHandlers(): void {
}
})
+ ipcMain.on('agentStatus:dropPersisted', (_event, request: unknown) => {
+ if (!isValidAgentStatusCacheIdentity(request)) {
+ return
+ }
+ try {
+ if (agentHookServer.dropPersistedStatusEntry(request)) {
+ clearMigrationUnsupportedPtysForPaneKey(request.paneKey)
+ }
+ } catch (err) {
+ console.warn('[agent-hooks] dropPersistedStatusEntry failed:', err)
+ }
+ })
+
+ ipcMain.on('agentStatus:dropPersistedBatch', (_event, request: unknown) => {
+ if (!Array.isArray(request) || request.length > MAX_DROP_PERSISTED_BATCH) {
+ return
+ }
+ const identities = request.filter(isValidAgentStatusCacheIdentity)
+ if (identities.length === 0) {
+ return
+ }
+ try {
+ for (const paneKey of agentHookServer.dropPersistedStatusEntries(identities)) {
+ clearMigrationUnsupportedPtysForPaneKey(paneKey)
+ }
+ } catch (err) {
+ console.warn('[agent-hooks] dropPersistedStatusEntries failed:', err)
+ }
+ })
+
ipcMain.on('agentStatus:reconcileEndedProcess', (_event, paneKey: unknown) => {
if (typeof paneKey !== 'string' || !isValidPaneKey(paneKey)) {
return
@@ -67,3 +103,18 @@ export function registerAgentStatusRowTeardownIpcHandlers(): void {
}
})
}
+
+function isValidAgentStatusCacheIdentity(value: unknown): value is AgentStatusCacheIdentity {
+ if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+ return false
+ }
+ const request = value as Record
+ return (
+ typeof request.paneKey === 'string' &&
+ isValidPaneKey(request.paneKey) &&
+ typeof request.receivedAt === 'number' &&
+ Number.isFinite(request.receivedAt) &&
+ typeof request.stateStartedAt === 'number' &&
+ Number.isFinite(request.stateStartedAt)
+ )
+}
diff --git a/src/main/persistence/applying-settings/ui-state-read.ts b/src/main/persistence/applying-settings/ui-state-read.ts
index 7a249934260..a640f971f89 100644
--- a/src/main/persistence/applying-settings/ui-state-read.ts
+++ b/src/main/persistence/applying-settings/ui-state-read.ts
@@ -62,6 +62,7 @@ export function getPersistedUI(
markdownTocPanelWidth: clampMarkdownTocPanelWidth(state.ui?.markdownTocPanelWidth),
combinedDiffFileTreeWidth: clampCombinedDiffFileTreeWidth(state.ui?.combinedDiffFileTreeWidth),
visibleWorkspaceHostIds: normalizeVisibleExecutionHostIds(state.ui?.visibleWorkspaceHostIds),
+ agentsVisibleHostIds: normalizeVisibleExecutionHostIds(state.ui?.agentsVisibleHostIds),
workspaceHostOrder: normalizeExecutionHostOrder(state.ui?.workspaceHostOrder),
manualRepoOrder: normalizeManualRepoOrder(state.ui?.manualRepoOrder),
browserDefaultZoomLevel: normalizeBrowserPageZoomLevel(state.ui?.browserDefaultZoomLevel),
diff --git a/src/main/persistence/applying-settings/ui-state-update.ts b/src/main/persistence/applying-settings/ui-state-update.ts
index b93ddfb1296..db06a2738fd 100644
--- a/src/main/persistence/applying-settings/ui-state-update.ts
+++ b/src/main/persistence/applying-settings/ui-state-update.ts
@@ -152,6 +152,10 @@ export function updatePersistedUI(
sanitizedUpdates.visibleWorkspaceHostIds !== undefined
? normalizeVisibleExecutionHostIds(sanitizedUpdates.visibleWorkspaceHostIds)
: normalizeVisibleExecutionHostIds(operations.state.ui?.visibleWorkspaceHostIds),
+ agentsVisibleHostIds:
+ sanitizedUpdates.agentsVisibleHostIds !== undefined
+ ? normalizeVisibleExecutionHostIds(sanitizedUpdates.agentsVisibleHostIds)
+ : normalizeVisibleExecutionHostIds(operations.state.ui?.agentsVisibleHostIds),
workspaceHostOrder:
sanitizedUpdates.workspaceHostOrder !== undefined
? normalizeExecutionHostOrder(sanitizedUpdates.workspaceHostOrder)
diff --git a/src/main/persistence/loading-store/normalize-loaded-global-settings.test.ts b/src/main/persistence/loading-store/normalize-loaded-global-settings.test.ts
new file mode 100644
index 00000000000..6d1040f09ae
--- /dev/null
+++ b/src/main/persistence/loading-store/normalize-loaded-global-settings.test.ts
@@ -0,0 +1,80 @@
+import { homedir } from 'node:os'
+import { describe, expect, it } from 'vitest'
+import { getDefaultPersistedState } from '../../../shared/constants'
+import { normalizeLoadedGlobalSettings } from './normalize-loaded-global-settings'
+import { prepareLoadedTerminalSettings } from './prepare-loaded-terminal-settings'
+import { prepareLoadedProfileSettings } from './prepare-loaded-profile-settings'
+import type { GlobalSettings } from '../../../shared/global-settings-types'
+import type { PersistedState } from '../../../shared/persisted-state-types'
+
+// Simulates a profile created before the dedicated Experimental switch was persisted.
+function normalizeLegacyProfile(overrides: Partial): PersistedState['settings'] {
+ const defaults = getDefaultPersistedState(homedir())
+ const settings: Partial = { ...defaults.settings }
+ delete settings.showAgentsSidebar
+ delete settings.experimentalActivity
+ delete settings.experimentalAgentDashboardPopout
+ Object.assign(settings, overrides)
+ const parsed: PersistedState = { ...defaults, settings: settings as GlobalSettings }
+ const noop = (): void => {}
+ const terminal = prepareLoadedTerminalSettings(parsed, noop)
+ const profile = prepareLoadedProfileSettings(parsed, defaults, noop)
+ return normalizeLoadedGlobalSettings(parsed, terminal, profile)
+}
+
+describe('showAgentsSidebar experimental-setting migration', () => {
+ it('keeps the sidebar for Agents-view opt-ins regardless of the dashboard experiment', () => {
+ const normalized = normalizeLegacyProfile({
+ experimentalActivity: true,
+ experimentalAgentDashboardPopout: false
+ })
+ expect(normalized.showAgentsSidebar).toBe(true)
+ expect(normalized.agentsSidebarMigratedFromExperimental).toBe(true)
+ })
+
+ it('carries the legacy Agents-view opt-in into the sidebar', () => {
+ expect(normalizeLegacyProfile({ experimentalActivity: true }).showAgentsSidebar).toBe(true)
+ })
+
+ it('does not show Agents migration copy for a dashboard-only opt-in', () => {
+ expect(
+ normalizeLegacyProfile({ experimentalAgentDashboardPopout: true })
+ .agentsSidebarMigratedFromExperimental
+ ).toBe(false)
+ })
+
+ it('defaults profiles with no legacy signal to the sidebar', () => {
+ const normalized = normalizeLegacyProfile({})
+ expect(normalized.showAgentsSidebar).toBe(true)
+ expect(normalized.agentsSidebarMigratedFromExperimental).toBe(false)
+ })
+
+ it('does not treat a dashboard opt-out as an Agents-tab opt-out', () => {
+ expect(
+ normalizeLegacyProfile({ experimentalAgentDashboardPopout: false }).showAgentsSidebar
+ ).toBe(true)
+ })
+
+ it('ignores a pre-stamp forced-default experimentalActivity true (not an opt-in)', () => {
+ const normalized = normalizeLegacyProfile({
+ experimentalActivity: true,
+ experimentalActivityDefaultedOffForAllUsers: undefined
+ })
+ expect(normalized.experimentalActivity).toBe(false)
+ expect(normalized.showAgentsSidebar).toBe(true)
+ expect(normalized.agentsSidebarMigratedFromExperimental).toBe(false)
+ })
+
+ it('preserves a stored showAgentsSidebar choice over legacy flags', () => {
+ expect(
+ normalizeLegacyProfile({ showAgentsSidebar: false, experimentalActivity: true })
+ .showAgentsSidebar
+ ).toBe(false)
+ expect(
+ normalizeLegacyProfile({
+ showAgentsSidebar: true,
+ experimentalAgentDashboardPopout: false
+ }).showAgentsSidebar
+ ).toBe(true)
+ })
+})
diff --git a/src/main/persistence/loading-store/normalize-loaded-global-settings.ts b/src/main/persistence/loading-store/normalize-loaded-global-settings.ts
index fb5cc9f1fe8..9370ec4febc 100644
--- a/src/main/persistence/loading-store/normalize-loaded-global-settings.ts
+++ b/src/main/persistence/loading-store/normalize-loaded-global-settings.ts
@@ -1,4 +1,5 @@
import { getDefaultVoiceSettings } from '../../../shared/constants'
+import { resolveAgentsSidebarVisible } from '../../../shared/agents-sidebar-visibility'
import { normalizePRBotAuthorOverrides } from '../../../shared/pr-bot-author-overrides'
import { normalizeTerminalQuickCommands } from '../../../shared/terminal-quick-commands'
import { normalizeOpenInApplications } from '../../../shared/open-in-applications'
@@ -85,6 +86,16 @@ export function normalizeLoadedGlobalSettings(
...migratedTerminalTuiScrollSensitivity.settings,
experimentalActivity: migratedExperimentalActivity,
experimentalActivityDefaultedOffForAllUsers: true,
+ // Keep the experimental Agents tab's rollout default for older profiles while
+ // preserving any choice made through its dedicated Experimental setting.
+ showAgentsSidebar: resolveAgentsSidebarVisible({
+ showAgentsSidebar: parsed.settings?.showAgentsSidebar
+ }),
+ // Preserve the legacy opt-in before the experimental setting is normalized away. This
+ // drives the migration-specific introduction copy without changing runtime behavior.
+ agentsSidebarMigratedFromExperimental:
+ parsed.settings?.agentsSidebarMigratedFromExperimental === true ||
+ migratedExperimentalActivity,
// Why: compact worktree cards graduated from Experimental; preserve the old opt-in for rollout-era profiles.
compactWorktreeCards: loadedCompactWorktreeCards,
experimentalCompactWorktreeCards: undefined,
diff --git a/src/main/persistence/loading-store/workspace-session-snapshot-publication.ts b/src/main/persistence/loading-store/workspace-session-snapshot-publication.ts
index 97cd3b2b544..5b7f90cbb8f 100644
--- a/src/main/persistence/loading-store/workspace-session-snapshot-publication.ts
+++ b/src/main/persistence/loading-store/workspace-session-snapshot-publication.ts
@@ -15,6 +15,8 @@ import { registerPersistedPaneKeyAlias } from '../restoring-sessions/pane-alias-
import {
normalizeWorkspaceSessionPaneIdentities,
remapAcknowledgedAgentPaneKeys,
+ remapActivityClearedAtPaneKeys,
+ remapManuallyUnreadTurnPaneKeys,
remapSshRemotePtyLeaseLeafIds,
type WorkspaceSessionPaneIdentityRemap
} from '../restoring-sessions/workspace-pane-normalization'
@@ -50,10 +52,30 @@ export function setLocalWorkspaceSession(
context.runtime.state.ui?.acknowledgedAgentsByPaneKey,
normalized.leafIdByInputLeafIdByTabId
)
- if (remappedAcknowledgements.changed) {
+ const remappedActivityCutoffs = remapActivityClearedAtPaneKeys(
+ context.runtime.state.ui?.activityClearedAtByPaneKey,
+ normalized.leafIdByInputLeafIdByTabId
+ )
+ const remappedManualUnread = remapManuallyUnreadTurnPaneKeys(
+ context.runtime.state.ui?.manuallyUnreadTurnsByPaneKey,
+ normalized.leafIdByInputLeafIdByTabId
+ )
+ if (
+ remappedAcknowledgements.changed ||
+ remappedActivityCutoffs.changed ||
+ remappedManualUnread.changed
+ ) {
context.runtime.state.ui = {
...context.runtime.state.ui,
- acknowledgedAgentsByPaneKey: remappedAcknowledgements.acknowledgements
+ ...(remappedAcknowledgements.changed
+ ? { acknowledgedAgentsByPaneKey: remappedAcknowledgements.acknowledgements }
+ : {}),
+ ...(remappedActivityCutoffs.changed
+ ? { activityClearedAtByPaneKey: remappedActivityCutoffs.cutoffs }
+ : {}),
+ ...(remappedManualUnread.changed
+ ? { manuallyUnreadTurnsByPaneKey: remappedManualUnread.turns }
+ : {})
}
}
for (const entry of normalized.legacyPaneKeyAliasEntries) {
diff --git a/src/main/persistence/restoring-sessions/pane-key-remapping.test.ts b/src/main/persistence/restoring-sessions/pane-key-remapping.test.ts
new file mode 100644
index 00000000000..c0359efd612
--- /dev/null
+++ b/src/main/persistence/restoring-sessions/pane-key-remapping.test.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import { makePaneKey } from '../../../shared/stable-pane-id'
+import {
+ remapActivityClearedAtPaneKeys,
+ remapManuallyUnreadTurnPaneKeys
+} from './pane-key-remapping'
+
+const STABLE_LEAF_ID = '00000000-0000-4000-8000-000000000001'
+
+describe('remapManuallyUnreadTurnPaneKeys', () => {
+ it('promotes legacy pane keys to the restored stable leaf like clear-completed cutoffs', () => {
+ const remap = new Map([['tab-1', new Map([['pane:1', STABLE_LEAF_ID]])]])
+ const turns = { 'tab-1:pane:1': 42, 'tab-2:pane:9': 7 }
+
+ const result = remapManuallyUnreadTurnPaneKeys(turns, remap)
+
+ expect(result.changed).toBe(true)
+ expect(result.turns).toEqual({ [makePaneKey('tab-1', STABLE_LEAF_ID)]: 42, 'tab-2:pane:9': 7 })
+ // Same remap contract as the cutoffs so the two never drift after a session restore.
+ expect(remapActivityClearedAtPaneKeys(turns, remap).cutoffs).toEqual(result.turns)
+ })
+
+ it('reports no change for empty or already-stable records', () => {
+ const remap = new Map([['tab-1', new Map([['pane:1', STABLE_LEAF_ID]])]])
+ expect(remapManuallyUnreadTurnPaneKeys(undefined, remap).changed).toBe(false)
+ expect(remapManuallyUnreadTurnPaneKeys({}, remap).changed).toBe(false)
+ const stable = { [makePaneKey('tab-1', STABLE_LEAF_ID)]: 1 }
+ expect(remapManuallyUnreadTurnPaneKeys(stable, remap)).toEqual({
+ turns: stable,
+ changed: false
+ })
+ })
+})
diff --git a/src/main/persistence/restoring-sessions/pane-key-remapping.ts b/src/main/persistence/restoring-sessions/pane-key-remapping.ts
new file mode 100644
index 00000000000..4f3440f087e
--- /dev/null
+++ b/src/main/persistence/restoring-sessions/pane-key-remapping.ts
@@ -0,0 +1,75 @@
+import type { PersistedState } from '../../../shared/persisted-state-types'
+import { isTerminalLeafId, makePaneKey, parsePaneKey } from '../../../shared/stable-pane-id'
+
+type PaneLeafRemap = Map>
+
+function remapPaneKeys(
+ values: Record | undefined,
+ leafIdByInputLeafIdByTabId: PaneLeafRemap
+): { values: Record | undefined; changed: boolean } {
+ if (!values || Object.keys(values).length === 0) {
+ return { values, changed: false }
+ }
+
+ let changed = false
+ const next: Record = {}
+ const setValue = (paneKey: string, value: T): void => {
+ const existing = next[paneKey]
+ next[paneKey] = existing === undefined ? value : (Math.max(existing, value) as T)
+ }
+ for (const [paneKey, value] of Object.entries(values)) {
+ const parsed = parsePaneKey(paneKey)
+ if (parsed) {
+ setValue(paneKey, value)
+ continue
+ }
+
+ const delimiter = paneKey.indexOf(':')
+ if (delimiter <= 0 || delimiter === paneKey.length - 1) {
+ setValue(paneKey, value)
+ continue
+ }
+
+ const tabId = paneKey.slice(0, delimiter)
+ const legacyLeafId = paneKey.slice(delimiter + 1)
+ const remappedLeafId = leafIdByInputLeafIdByTabId.get(tabId)?.get(legacyLeafId)
+ if (!remappedLeafId || !isTerminalLeafId(remappedLeafId)) {
+ setValue(paneKey, value)
+ continue
+ }
+
+ try {
+ // Carry values over when a legacy leaf is promoted to a UUID.
+ setValue(makePaneKey(tabId, remappedLeafId), value)
+ changed = true
+ } catch {
+ setValue(paneKey, value)
+ }
+ }
+
+ return { values: next, changed }
+}
+
+export function remapAcknowledgedAgentPaneKeys(
+ acknowledgements: PersistedState['ui']['acknowledgedAgentsByPaneKey'],
+ leafIdByInputLeafIdByTabId: PaneLeafRemap
+): { acknowledgements: PersistedState['ui']['acknowledgedAgentsByPaneKey']; changed: boolean } {
+ const result = remapPaneKeys(acknowledgements, leafIdByInputLeafIdByTabId)
+ return { acknowledgements: result.values, changed: result.changed }
+}
+
+export function remapManuallyUnreadTurnPaneKeys(
+ turns: PersistedState['ui']['manuallyUnreadTurnsByPaneKey'],
+ leafIdByInputLeafIdByTabId: PaneLeafRemap
+): { turns: PersistedState['ui']['manuallyUnreadTurnsByPaneKey']; changed: boolean } {
+ const result = remapPaneKeys(turns, leafIdByInputLeafIdByTabId)
+ return { turns: result.values, changed: result.changed }
+}
+
+export function remapActivityClearedAtPaneKeys(
+ cutoffs: PersistedState['ui']['activityClearedAtByPaneKey'],
+ leafIdByInputLeafIdByTabId: PaneLeafRemap
+): { cutoffs: PersistedState['ui']['activityClearedAtByPaneKey']; changed: boolean } {
+ const result = remapPaneKeys(cutoffs, leafIdByInputLeafIdByTabId)
+ return { cutoffs: result.values, changed: result.changed }
+}
diff --git a/src/main/persistence/restoring-sessions/workspace-pane-normalization.ts b/src/main/persistence/restoring-sessions/workspace-pane-normalization.ts
index 2bfafebae9f..cfc26c7bb8a 100644
--- a/src/main/persistence/restoring-sessions/workspace-pane-normalization.ts
+++ b/src/main/persistence/restoring-sessions/workspace-pane-normalization.ts
@@ -8,7 +8,7 @@ import {
type ExecutionHostId
} from '../../../shared/execution-host'
import type { SshRemotePtyLease } from '../../../shared/ssh-types'
-import { isTerminalLeafId, makePaneKey, parsePaneKey } from '../../../shared/stable-pane-id'
+import { isTerminalLeafId, parsePaneKey } from '../../../shared/stable-pane-id'
import { findCrossHostPaneTabIds, withoutPaneTabIds } from './cross-host-pane-tab-ids'
import {
createLazyTerminalTabLookup,
@@ -22,6 +22,17 @@ import {
migrationUnsupportedEntriesEqual,
normalizeLegacyPaneKeyAliasEntries
} from './pane-alias-normalization'
+import {
+ remapAcknowledgedAgentPaneKeys,
+ remapActivityClearedAtPaneKeys,
+ remapManuallyUnreadTurnPaneKeys
+} from './pane-key-remapping'
+
+export {
+ remapAcknowledgedAgentPaneKeys,
+ remapActivityClearedAtPaneKeys,
+ remapManuallyUnreadTurnPaneKeys
+} from './pane-key-remapping'
export function normalizeWorkspaceSessionPaneIdentities(
session: WorkspaceSessionState,
@@ -220,6 +231,14 @@ export function normalizePersistedPaneIdentityState(state: PersistedState): {
state.ui?.acknowledgedAgentsByPaneKey,
withoutPaneTabIds(acknowledgementLeafIdByInputLeafIdByTabId, crossHostTabIds)
)
+ const remappedActivityCutoffs = remapActivityClearedAtPaneKeys(
+ state.ui?.activityClearedAtByPaneKey,
+ withoutPaneTabIds(acknowledgementLeafIdByInputLeafIdByTabId, crossHostTabIds)
+ )
+ const remappedManualUnread = remapManuallyUnreadTurnPaneKeys(
+ state.ui?.manuallyUnreadTurnsByPaneKey,
+ withoutPaneTabIds(acknowledgementLeafIdByInputLeafIdByTabId, crossHostTabIds)
+ )
const migrationUnsupportedChanged = !migrationUnsupportedEntriesEqual(
state.migrationUnsupportedPtyEntries ?? [],
mergedMigrationUnsupportedEntries
@@ -234,7 +253,9 @@ export function normalizePersistedPaneIdentityState(state: PersistedState): {
!remappedLeases.changed &&
!migrationUnsupportedChanged &&
!legacyAliasesChanged &&
- !remappedAcknowledgements.changed
+ !remappedAcknowledgements.changed &&
+ !remappedActivityCutoffs.changed &&
+ !remappedManualUnread.changed
) {
return {
state,
@@ -251,11 +272,21 @@ export function normalizePersistedPaneIdentityState(state: PersistedState): {
sshRemotePtyLeases: remappedLeases.leases,
migrationUnsupportedPtyEntries: mergedMigrationUnsupportedEntries,
legacyPaneKeyAliasEntries: mergedLegacyPaneKeyAliasEntries,
- ...(remappedAcknowledgements.changed
+ ...(remappedAcknowledgements.changed ||
+ remappedActivityCutoffs.changed ||
+ remappedManualUnread.changed
? {
ui: {
...state.ui,
- acknowledgedAgentsByPaneKey: remappedAcknowledgements.acknowledgements
+ ...(remappedAcknowledgements.changed
+ ? { acknowledgedAgentsByPaneKey: remappedAcknowledgements.acknowledgements }
+ : {}),
+ ...(remappedActivityCutoffs.changed
+ ? { activityClearedAtByPaneKey: remappedActivityCutoffs.cutoffs }
+ : {}),
+ ...(remappedManualUnread.changed
+ ? { manuallyUnreadTurnsByPaneKey: remappedManualUnread.turns }
+ : {})
}
}
: {})
@@ -265,50 +296,3 @@ export function normalizePersistedPaneIdentityState(state: PersistedState): {
legacyPaneKeyAliasEntries: mergedLegacyPaneKeyAliasEntries
}
}
-
-export function remapAcknowledgedAgentPaneKeys(
- acknowledgements: PersistedState['ui']['acknowledgedAgentsByPaneKey'],
- leafIdByInputLeafIdByTabId: Map>
-): { acknowledgements: PersistedState['ui']['acknowledgedAgentsByPaneKey']; changed: boolean } {
- if (!acknowledgements || Object.keys(acknowledgements).length === 0) {
- return { acknowledgements, changed: false }
- }
-
- let changed = false
- const next: NonNullable = {}
- const setAcknowledgement = (paneKey: string, acknowledgedAt: number): void => {
- const existing = next[paneKey]
- next[paneKey] = existing === undefined ? acknowledgedAt : Math.max(existing, acknowledgedAt)
- }
- for (const [paneKey, acknowledgedAt] of Object.entries(acknowledgements)) {
- const parsed = parsePaneKey(paneKey)
- if (parsed) {
- setAcknowledgement(paneKey, acknowledgedAt)
- continue
- }
-
- const delimiter = paneKey.indexOf(':')
- if (delimiter <= 0 || delimiter === paneKey.length - 1) {
- setAcknowledgement(paneKey, acknowledgedAt)
- continue
- }
-
- const tabId = paneKey.slice(0, delimiter)
- const legacyLeafId = paneKey.slice(delimiter + 1)
- const remappedLeafId = leafIdByInputLeafIdByTabId.get(tabId)?.get(legacyLeafId)
- if (!remappedLeafId || !isTerminalLeafId(remappedLeafId)) {
- setAcknowledgement(paneKey, acknowledgedAt)
- continue
- }
-
- try {
- // Why: when a legacy leaf is promoted to a UUID, carry the read marker over so seen rows don't come back unread.
- setAcknowledgement(makePaneKey(tabId, remappedLeafId), acknowledgedAt)
- changed = true
- } catch {
- setAcknowledgement(paneKey, acknowledgedAt)
- }
- }
-
- return { acknowledgements: next, changed }
-}
diff --git a/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts b/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
index 02c93c14f6b..d6c08ad44cf 100644
--- a/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
+++ b/src/main/runtime/rpc/methods/client-ui-pairing-local-fields.test.ts
@@ -44,7 +44,13 @@ describe('client UI RPC pairing-local field seams', () => {
manualRepoOrder: [
{ hostId: 'runtime:web-11111111-2222-3333-4444-555555555555', repoId: 'repo-a' }
],
- workspaceHostOrder: ['runtime:web-11111111-2222-3333-4444-555555555555', 'local']
+ workspaceHostOrder: ['runtime:web-11111111-2222-3333-4444-555555555555', 'local'],
+ agentsVisibleHostIds: ['runtime:web-11111111-2222-3333-4444-555555555555'],
+ agentsFilterRepoIds: ['repo-a'],
+ agentsShowChildAgents: true,
+ agentsCompactMode: false,
+ activityClearedAtByPaneKey: { 'tab-1:leaf-1': 123 },
+ manuallyUnreadTurnsByPaneKey: { 'tab-1:leaf-1': 321 }
}
it.each(PAIRING_LOCAL_UI_FIELDS.map((field) => [field] as const))(
diff --git a/src/main/runtime/rpc/methods/client-ui-schemas.ts b/src/main/runtime/rpc/methods/client-ui-schemas.ts
index 79b923a55db..edb3f651c32 100644
--- a/src/main/runtime/rpc/methods/client-ui-schemas.ts
+++ b/src/main/runtime/rpc/methods/client-ui-schemas.ts
@@ -122,6 +122,10 @@ const UiUpdateFields = z
showInactiveWorkspaces: z.boolean().optional(),
workspaceHostScope: z.string().optional(),
visibleWorkspaceHostIds: z.array(z.string()).nullable().optional(),
+ agentsVisibleHostIds: z.array(z.string()).nullable().optional(),
+ agentsFilterRepoIds: StringArray.optional(),
+ agentsShowChildAgents: z.boolean().optional(),
+ agentsCompactMode: z.boolean().optional(),
workspaceHostOrder: z.array(z.string()).optional(),
automationHostFilter: z
.union([
@@ -171,6 +175,8 @@ const UiUpdateFields = z
updateReassuranceSeen: z.boolean().optional(),
osc52ClipboardDefaultOnNoticePending: z.boolean().optional(),
acknowledgedAgentsByPaneKey: z.record(z.string(), z.number().finite()).optional(),
+ activityClearedAtByPaneKey: z.record(z.string(), z.number().finite()).optional(),
+ manuallyUnreadTurnsByPaneKey: z.record(z.string(), z.number().finite()).optional(),
browserDefaultUrl: NullableString.optional(),
browserDefaultSearchEngine: z
.enum(['google', 'duckduckgo', 'bing', 'kagi'])
diff --git a/src/preload/api/agent-status-api.ts b/src/preload/api/agent-status-api.ts
index fd6da88e351..7aa6c21115d 100644
--- a/src/preload/api/agent-status-api.ts
+++ b/src/preload/api/agent-status-api.ts
@@ -1,4 +1,5 @@
import type {
+ AgentStatusCacheIdentity,
AgentStatusClearIpcPayload,
AgentStatusIpcPayload,
MigrationUnsupportedPtyEntry
@@ -30,6 +31,10 @@ export type AgentStatusApi = {
getMigrationUnsupportedSnapshot: () => Promise
/** Drop a paneKey from the main-process hook cache and on-disk last-status file. Fire-and-forget. */
drop: (paneKey: string) => void
+ /** Evict a previously-cleared status only when its identity still matches the main-process cache. */
+ dropPersisted: (identity: AgentStatusCacheIdentity) => void
+ /** Same as dropPersisted for many identities in one IPC message and one listener notification. */
+ dropPersistedBatch?: (identities: readonly AgentStatusCacheIdentity[]) => void
/** Retire a pane whose agent process is proven gone — clears the row AND the per-pane caches a
* dismissal deliberately keeps. Not `drop`: that one is a user dismissal of a live pane's row. */
reconcileEndedProcess: (paneKey: string) => void
diff --git a/src/preload/api/agent-status-bridge.ts b/src/preload/api/agent-status-bridge.ts
index b5ac5c8b5b2..3cc1654aaed 100644
--- a/src/preload/api/agent-status-bridge.ts
+++ b/src/preload/api/agent-status-bridge.ts
@@ -1,5 +1,6 @@
import { ipcRenderer } from 'electron'
import type {
+ AgentStatusCacheIdentity,
AgentStatusClearIpcPayload,
AgentStatusIpcPayload,
MigrationUnsupportedPtyEntry
@@ -66,6 +67,12 @@ export const agentStatusApi = {
drop: (paneKey: string): void => {
ipcRenderer.send('agentStatus:drop', paneKey)
},
+ dropPersisted: (identity: AgentStatusCacheIdentity): void => {
+ ipcRenderer.send('agentStatus:dropPersisted', identity)
+ },
+ dropPersistedBatch: (identities: readonly AgentStatusCacheIdentity[]): void => {
+ ipcRenderer.send('agentStatus:dropPersistedBatch', identities)
+ },
reconcileEndedProcess: (paneKey: string): void => {
ipcRenderer.send('agentStatus:reconcileEndedProcess', paneKey)
},
diff --git a/src/renderer/src/app-shell/use-app-startup-hydration.ts b/src/renderer/src/app-shell/use-app-startup-hydration.ts
index 2b5272f440d..447fbfb3780 100644
--- a/src/renderer/src/app-shell/use-app-startup-hydration.ts
+++ b/src/renderer/src/app-shell/use-app-startup-hydration.ts
@@ -269,6 +269,16 @@ export function useAppStartupHydration(onOnboardingLoaded: (state: OnboardingSta
// Why (issue #1158): unlock the session writer only after hydration and all dependent steps succeeded, so a mid-startup throw can't serialize partially-mutated state to disk.
actions.setHydrationSucceeded(true)
actions.setTerminalStartupRestorationReady(true)
+ // Why the explicit opt-in: unconditional seeding hijacks every empty dev
+ // profile's active workspace, making onboarding/empty-state flows untestable.
+ if (
+ import.meta.env.DEV &&
+ String(import.meta.env.VITE_ACTIVITY_DEV_FIXTURE).toLowerCase() === 'true'
+ ) {
+ const { seedDevActivityFixture } =
+ await import('../components/activity/dev-activity-fixture')
+ seedDevActivityFixture()
+ }
logRendererStartupDiagnostic('startup-hydration-done', {
durationMs: Math.round(performance.now() - startupStartedAt)
})
diff --git a/src/renderer/src/app-shell/use-persisted-ui-writer.ts b/src/renderer/src/app-shell/use-persisted-ui-writer.ts
index 857b55fc8a4..19109c25eb2 100644
--- a/src/renderer/src/app-shell/use-persisted-ui-writer.ts
+++ b/src/renderer/src/app-shell/use-persisted-ui-writer.ts
@@ -167,7 +167,11 @@ export function usePersistedUIWriter(): void {
// paths in agent-status.ts (close/dismiss) flow to disk through map identity changes.
// Without persisting, agent rows that survive restart come back bold even when the
// user had already visited them.
- acknowledgedAgentsByPaneKey: s.acknowledgedAgentsByPaneKey
+ acknowledgedAgentsByPaneKey: s.acknowledgedAgentsByPaneKey,
+ // Why: "Clear completed" must survive restart, or cleared done/interrupted rows return.
+ activityClearedAtByPaneKey: s.activityClearedAtByPaneKey,
+ // Why: an explicit "mark unread" must survive restart, or the row comes back read.
+ manuallyUnreadTurnsByPaneKey: s.manuallyUnreadTurnsByPaneKey
}))
)
useEffect(() => {
diff --git a/src/renderer/src/components/activity/ActivityPrototypePage.test.ts b/src/renderer/src/components/activity/ActivityPrototypePage.test.ts
index 48bdbb3a250..9ccf93248dc 100644
--- a/src/renderer/src/components/activity/ActivityPrototypePage.test.ts
+++ b/src/renderer/src/components/activity/ActivityPrototypePage.test.ts
@@ -399,7 +399,7 @@ describe('buildActivityEvents', () => {
expect(threads[0].events[0].entry.prompt).toBe('Retained prior run')
})
- it('groups visible threads by current status order', () => {
+ it('groups visible threads with attention states before working and done', () => {
const repo = makeRepo()
const worktree = makeWorktree()
const workingTab = makeTab()
@@ -442,11 +442,49 @@ describe('buildActivityEvents', () => {
})
)
- expect(groups.map((group) => group.id)).toEqual(['working', 'blocked', 'done'])
+ expect(groups.map((group) => group.id)).toEqual(['blocked', 'working', 'done'])
expect(groups.map((group) => group.threads.map((thread) => thread.paneKey))).toEqual([
- [PANE_KEY],
[PANE_KEY_2],
+ [PANE_KEY],
[PANE_KEY_3]
])
})
+
+ it('merges runtime orchestration context into activity events and entries', () => {
+ const repo = makeRepo()
+ const worktree = makeWorktree()
+ const tab1 = makeTabWithIds('tab-1', worktree.id)
+ const tab2 = makeTabWithIds('tab-2', worktree.id)
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {
+ [PANE_KEY]: makeWorkingEntryWithoutHistory(),
+ [PANE_KEY_2]: {
+ ...makeWorkingEntryWithoutHistory(),
+ paneKey: PANE_KEY_2,
+ terminalHandle: 'terminal-child'
+ }
+ },
+ runtimeAgentOrchestrationByPaneKey: {
+ [PANE_KEY_2]: {
+ parentPaneKey: PANE_KEY,
+ parentTerminalHandle: 'terminal-parent',
+ taskId: 'task-counsel',
+ dispatchId: 'ctx-counsel'
+ }
+ },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: {
+ [worktree.id]: [tab1, tab2]
+ },
+ worktreeMap: new Map([[worktree.id, worktree]]),
+ repoMap: new Map([[repo.id, repo]]),
+ acknowledgedAgentsByPaneKey: {},
+ now: 5_000
+ })
+
+ expect(result.liveAgentByPaneKey[PANE_KEY_2].entry.orchestration?.parentPaneKey).toBe(PANE_KEY)
+ expect(result.liveAgentByPaneKey[PANE_KEY_2].entry.orchestration?.parentTerminalHandle).toBe(
+ 'terminal-parent'
+ )
+ })
})
diff --git a/src/renderer/src/components/activity/ActivityPrototypePage.thread-grouping.test.ts b/src/renderer/src/components/activity/ActivityPrototypePage.thread-grouping.test.ts
index 72a1b6d3355..0435f2c61f2 100644
--- a/src/renderer/src/components/activity/ActivityPrototypePage.thread-grouping.test.ts
+++ b/src/renderer/src/components/activity/ActivityPrototypePage.thread-grouping.test.ts
@@ -207,4 +207,17 @@ describe('activity thread grouping', () => {
it('returns no groups for empty thread input', () => {
expect(buildActivityThreadGroups([], 'status')).toEqual([])
})
+
+ it('keeps all threads in one ungrouped list', () => {
+ const threads = makeThreads(
+ makeActivityResult({
+ entries: {
+ [PANE_KEY]: makeWorkingEntryWithoutHistory(),
+ [PANE_KEY_2]: makeWorkingEntryWithoutHistory()
+ }
+ })
+ )
+
+ expect(buildActivityThreadGroups(threads, 'none')).toEqual([{ key: 'all', label: '', threads }])
+ })
})
diff --git a/src/renderer/src/components/activity/ActivityPrototypePage.tsx b/src/renderer/src/components/activity/ActivityPrototypePage.tsx
index 59fa8a0f1a0..83581d4cf10 100644
--- a/src/renderer/src/components/activity/ActivityPrototypePage.tsx
+++ b/src/renderer/src/components/activity/ActivityPrototypePage.tsx
@@ -1,8 +1,7 @@
import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import { useShallow } from 'zustand/react/shallow'
-import { useSidebarResize } from '@/hooks/useSidebarResize'
import { useAppStore } from '@/store'
-import { getRepoMapFromState, getWorktreeMapFromState } from '@/store/selectors'
+import { useSidebarResize } from '@/hooks/useSidebarResize'
+import { ActivityScopeFilterChips } from './activity-scope-filter-controls'
import {
setActivityTerminalPortals,
type ActivityTerminalPortalTarget
@@ -11,15 +10,10 @@ import {
reconcileActivityPortalThreads,
resolveActivityPortalSwap
} from './activity-portal-thread-reconciliation'
-import { buildActivityEvents } from './activity-event-builder'
-import { buildAgentPaneThreads } from './activity-thread-builder'
-import {
- activityThreadMatchesSearchQuery,
- buildActivityThreadGroups,
- isActivitySearchQueryTooLarge
-} from './activity-thread-grouping'
+import { useAgentPaneThreads } from './use-agent-pane-threads'
import { handleActivityFilterFocusShortcut } from './activity-filter-focus-shortcut'
-import { createActivityThreadActions } from './activity-thread-actions'
+import { hasActivityThreadWorkspace } from './activity-thread-actions'
+import { useActivityThreadActionBindings } from './use-activity-thread-action-bindings'
import { ActivityThreadListPane } from './activity-thread-list-pane'
import { ActivityThreadDetailPane } from './activity-thread-detail-pane'
import {
@@ -42,7 +36,11 @@ export default function ActivityPrototypePage(): React.JSX.Element {
const activityFilterInputRef = useRef(null)
// Why: bounds auto mark-read to one acknowledgement per selected thread turn.
const autoAcknowledgedTurnRef = useRef(null)
- const [compactMode, setCompactMode] = useState(false)
+ // Why store-backed: persisted preferences shared with the sidebar agents list.
+ const compactMode = useAppStore((s) => s.agentsCompactMode)
+ const setCompactMode = useAppStore((s) => s.setAgentsCompactMode)
+ const showChildAgents = useAppStore((s) => s.agentsShowChildAgents)
+ const setShowChildAgents = useAppStore((s) => s.setAgentsShowChildAgents)
const [selectedPaneKey, setSelectedPaneKey] = useState(null)
const [displayedPaneKey, setDisplayedPaneKey] = useState(null)
const [activePortalSlotId, setActivePortalSlotId] =
@@ -64,86 +62,30 @@ export default function ActivityPrototypePage(): React.JSX.Element {
setWidth: setThreadListWidth
})
- const storeData = useAppStore(
- useShallow((s) => ({
- agentStatusByPaneKey: s.agentStatusByPaneKey,
- migrationUnsupportedByPtyId: s.migrationUnsupportedByPtyId,
- retainedAgentsByPaneKey: s.retainedAgentsByPaneKey,
- tabsByWorktree: s.tabsByWorktree,
- worktreeMap: getWorktreeMapFromState(s),
- repoMap: getRepoMapFromState(s),
- acknowledgedAgentsByPaneKey: s.acknowledgedAgentsByPaneKey,
- acknowledgeAgents: s.acknowledgeAgents,
- unacknowledgeAgents: s.unacknowledgeAgents,
- generatedTitlesEnabled: s.settings?.tabAutoGenerateTitle === true
- }))
- )
- // Why: agentStatusEpoch is a dep (not used in the body) so the memo recomputes when freshness boundaries expire even without new PTY data.
- const agentStatusEpoch = useAppStore((s) => s.agentStatusEpoch)
-
- const { events: allEvents, liveAgentByPaneKey } = useMemo(
- () =>
- buildActivityEvents({
- agentStatusByPaneKey: storeData.agentStatusByPaneKey,
- migrationUnsupportedByPtyId: storeData.migrationUnsupportedByPtyId,
- retainedAgentsByPaneKey: storeData.retainedAgentsByPaneKey,
- tabsByWorktree: storeData.tabsByWorktree,
- worktreeMap: storeData.worktreeMap,
- repoMap: storeData.repoMap,
- acknowledgedAgentsByPaneKey: storeData.acknowledgedAgentsByPaneKey,
- // Why: Date.now() is read in the memo body (not a dep) so stale-decay recomputes when agentStatusEpoch ticks, not on wall-clock time.
- now: Date.now()
- }),
- // eslint-disable-next-line react-hooks/exhaustive-deps
- [storeData, agentStatusEpoch]
- )
-
- const allThreads = useMemo(
- () =>
- buildAgentPaneThreads({
- events: allEvents,
- liveAgentByPaneKey,
- generatedTitlesEnabled: storeData.generatedTitlesEnabled
- }),
- [allEvents, liveAgentByPaneKey, storeData.generatedTitlesEnabled]
- )
- const selectedPaneKeyIsLive =
- selectedPaneKey === null || allThreads.some((thread) => thread.paneKey === selectedPaneKey)
- const effectiveSelectedPaneKey = selectedPaneKeyIsLive ? selectedPaneKey : null
+ const {
+ storeData,
+ allThreads,
+ selectedPaneKeyIsLive,
+ effectiveSelectedPaneKey,
+ visibleThreads,
+ markAllReadThreads,
+ visibleThreadGroups
+ } = useAgentPaneThreads({ query, readFilter, groupBy, selectedPaneKey, showChildAgents })
if (!selectedPaneKeyIsLive) {
// Why: rows disappear when agent retention or tab state changes; clear stale selection before detail/portal rendering targets it.
setSelectedPaneKey(null)
}
- const visibleThreads = useMemo(() => {
- const normalizedQuery = isActivitySearchQueryTooLarge(query) ? null : query.trim().toLowerCase()
- return allThreads.filter((thread) => {
- // Why: keep the just-selected thread visible after auto-mark-read flips it to read, else unread-only mode makes the clicked row vanish from the list.
- if (
- readFilter === 'unread' &&
- !thread.unread &&
- thread.paneKey !== effectiveSelectedPaneKey
- ) {
- return false
- }
- if (normalizedQuery === null) {
- return false
- }
- return activityThreadMatchesSearchQuery({ thread, searchQuery: normalizedQuery })
- })
- }, [allThreads, readFilter, query, effectiveSelectedPaneKey])
- const visibleThreadGroups = useMemo(
- () => buildActivityThreadGroups(visibleThreads, groupBy),
- [visibleThreads, groupBy]
- )
-
const selectedThread = effectiveSelectedPaneKey
? (allThreads.find((thread) => thread.paneKey === effectiveSelectedPaneKey) ?? null)
: null
const selectedTabId = selectedThread?.tab.id ?? null
+ const selectedWorktreeAvailable = selectedThread
+ ? hasActivityThreadWorkspace(selectedThread, storeData)
+ : false
// Why: repo-less terminal buckets can produce Activity rows, but the workspace Terminal tree only portals real worktrees.
const selectedHasLiveTab =
- selectedThread && selectedTabId && storeData.worktreeMap.has(selectedThread.worktree.id)
+ selectedThread && selectedTabId && selectedWorktreeAvailable
? (storeData.tabsByWorktree[selectedThread.worktree.id] ?? []).some(
(tab) => tab.id === selectedTabId
)
@@ -152,8 +94,11 @@ export default function ActivityPrototypePage(): React.JSX.Element {
? (allThreads.find((thread) => thread.paneKey === displayedPaneKey) ?? null)
: null
const displayedTabId = displayedThread?.tab.id ?? null
+ const displayedWorktreeAvailable = displayedThread
+ ? hasActivityThreadWorkspace(displayedThread, storeData)
+ : false
const displayedHasLiveTab =
- displayedThread && displayedTabId && storeData.worktreeMap.has(displayedThread.worktree.id)
+ displayedThread && displayedTabId && displayedWorktreeAvailable
? (storeData.tabsByWorktree[displayedThread.worktree.id] ?? []).some(
(tab) => tab.id === displayedTabId
)
@@ -298,13 +243,38 @@ export default function ActivityPrototypePage(): React.JSX.Element {
return () => window.removeEventListener('keydown', focusActivityFilter, { capture: true })
}, [activePortalTargetEl, inactivePortalTargetEl])
- const { hasUnreadThreads, markThreadUnread, selectThread, jumpToWorkspace, markAllThreadsRead } =
- createActivityThreadActions({
- allThreads,
- acknowledgeAgents: storeData.acknowledgeAgents,
- unacknowledgeAgents: storeData.unacknowledgeAgents,
- setSelectedPaneKey
- })
+ const {
+ markThreadRead,
+ markThreadUnread,
+ selectThread,
+ jumpToWorkspace,
+ markAllThreadsRead,
+ hasUnreadThreads,
+ hasCompletedThreads,
+ handleClearCompleted
+ } = useActivityThreadActionBindings({
+ visibleThreads,
+ markAllReadThreads,
+ acknowledgeAgents: storeData.acknowledgeAgents,
+ unacknowledgeAgents: storeData.unacknowledgeAgents,
+ setSelectedPaneKey
+ })
+
+ const canJumpToWorkspace = useCallback(
+ (thread: Parameters[0]) =>
+ hasActivityThreadWorkspace(thread, {
+ worktreesByRepo: storeData.worktreesByRepo,
+ detectedWorktreesByRepo: storeData.detectedWorktreesByRepo,
+ folderWorkspaces: storeData.folderWorkspaces,
+ defaultHostId: storeData.defaultHostId
+ }),
+ [
+ storeData.worktreesByRepo,
+ storeData.detectedWorktreesByRepo,
+ storeData.folderWorkspaces,
+ storeData.defaultHostId
+ ]
+ )
useEffect(() => {
if (
@@ -356,25 +326,29 @@ export default function ActivityPrototypePage(): React.JSX.Element {
readFilter={readFilter}
onReadFilterChange={setReadFilter}
compactMode={compactMode}
+ showChildAgents={showChildAgents}
hasUnreadThreads={hasUnreadThreads}
onCompactModeChange={setCompactMode}
+ onShowChildAgentsChange={setShowChildAgents}
onMarkAllThreadsRead={markAllThreadsRead}
+ hasCompletedThreads={hasCompletedThreads}
+ onClearCompleted={handleClearCompleted}
visibleThreadGroups={visibleThreadGroups}
visibleThreadCount={visibleThreads.length}
selectedPaneKey={selectedThread?.paneKey ?? null}
onSelectThread={selectThread}
onJumpToWorkspace={jumpToWorkspace}
+ onMarkThreadRead={markThreadRead}
onMarkThreadUnread={markThreadUnread}
- canJumpToWorkspace={(thread) => storeData.worktreeMap.has(thread.worktree.id)}
+ canJumpToWorkspace={canJumpToWorkspace}
isThreadListResizing={isThreadListResizing}
onResizeStart={onResizeStart}
+ scopeFilterRow={ void
compactMode?: boolean
+ showChildAgents?: boolean
+ onShowChildAgentsChange?: (showChildAgents: boolean) => void
hasUnreadThreads?: boolean
}): ReactElement {
return (
{
expect(document.body.textContent).toContain('Compact mode')
})
+
+ it('renders group by options when provided', async () => {
+ const onGroupByChange = vi.fn()
+ await act(async () => {
+ root.render((
+ 'button[aria-label="Thread list options"]'
+ )
+
+ await act(async () => {
+ trigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'Enter' }))
+ })
+
+ expect(document.body.textContent).toContain('Group by')
+ expect(document.body.textContent).toContain('Status')
+
+ const subTrigger = document.querySelector(
+ '[data-slot="dropdown-menu-sub-trigger"]'
+ )
+ expect(subTrigger).not.toBeNull()
+
+ await act(async () => {
+ subTrigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'ArrowRight' }))
+ })
+
+ expect(document.body.textContent).toContain('Project')
+ expect(document.body.textContent).toContain('Worktree')
+ expect(document.body.textContent).toContain('Agent')
+ })
+
+ it('explains compact mode on hover', async () => {
+ await act(async () => {
+ root.render((
+ 'button[aria-label="Thread list options"]'
+ )
+ await act(async () => {
+ trigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'Enter' }))
+ })
+
+ const compactMode = document.querySelector('[role="menuitemcheckbox"]')
+ await act(async () => {
+ compactMode?.dispatchEvent(new Event('pointermove', { bubbles: true }))
+ })
+
+ expect(document.body.textContent).toContain(
+ 'Shows shorter thread rows with one-line titles and two-line status messages.'
+ )
+ })
+
+ it('puts search and unread actions in the menu when header overflow handlers are provided', async () => {
+ const onSearch = vi.fn()
+ const onToggleUnread = vi.fn()
+ await act(async () => {
+ root.render(
+
+
+ )
+ })
+
+ const trigger = container.querySelector(
+ 'button[aria-label="Thread list options"]'
+ )
+ await act(async () => {
+ trigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'Enter' }))
+ })
+
+ expect(document.body.textContent).toContain('Search')
+ expect(document.body.textContent).toContain('Show unread only')
+ })
+
+ it('explains show unread threads only on hover and shows unread dot when hasUnreadThreads is true', async () => {
+ const onToggleUnread = vi.fn()
+ await act(async () => {
+ root.render(
+
+
+ )
+ })
+
+ const trigger = container.querySelector(
+ 'button[aria-label="Thread list options"]'
+ )
+ await act(async () => {
+ trigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'Enter' }))
+ })
+
+ const unreadItem = document.querySelector('[role="menuitemcheckbox"]')
+ await act(async () => {
+ unreadItem?.dispatchEvent(new Event('pointermove', { bubbles: true }))
+ })
+
+ expect(document.body.textContent).toContain(
+ 'Filters the activity list to show only threads with unread updates.'
+ )
+ expect(document.querySelector('[data-unread-dot]')).not.toBeNull()
+ })
+
+ it('renders show child agents checkbox when onShowChildAgentsChange is provided', async () => {
+ const onShowChildAgentsChange = vi.fn()
+ await act(async () => {
+ root.render(
+ (
+ 'button[aria-label="Thread list options"]'
+ )
+
+ await act(async () => {
+ trigger?.dispatchEvent(new KeyboardEvent('keydown', { bubbles: true, key: 'Enter' }))
+ })
+
+ expect(document.body.textContent).toContain('Show child agents')
+ })
})
diff --git a/src/renderer/src/components/activity/ActivityTitlebarControls.tsx b/src/renderer/src/components/activity/ActivityTitlebarControls.tsx
index 93ca4c65c1c..c6194ffcc96 100644
--- a/src/renderer/src/components/activity/ActivityTitlebarControls.tsx
+++ b/src/renderer/src/components/activity/ActivityTitlebarControls.tsx
@@ -8,7 +8,7 @@ import { useActivityUnreadCount } from './useActivityUnreadCount'
import { translate } from '@/i18n/i18n'
export function ActivityTitlebarControls(): React.JSX.Element {
- const unreadCount = useActivityUnreadCount(true, 'agent-events')
+ const unreadCount = useActivityUnreadCount()
const closeActivityPage = useAppStore((s) => s.closeActivityPage)
return (
diff --git a/src/renderer/src/components/activity/activity-auto-mark-read-loop.react185.test.tsx b/src/renderer/src/components/activity/activity-auto-mark-read-loop.react185.test.tsx
index 9fdc4c0ecef..013afb58408 100644
--- a/src/renderer/src/components/activity/activity-auto-mark-read-loop.react185.test.tsx
+++ b/src/renderer/src/components/activity/activity-auto-mark-read-loop.react185.test.tsx
@@ -125,7 +125,7 @@ async function mountActivityPage(): Promise {
}
async function selectSeededThread(): Promise {
- const row = Array.from(seededContainer.querySelectorAll('[role="button"]')).find(
+ const row = Array.from(seededContainer.querySelectorAll('[role="listitem"]')).find(
(element) => element.textContent?.includes(PROMPT)
)
expect(row).toBeDefined()
diff --git a/src/renderer/src/components/activity/activity-clear-completed.test.ts b/src/renderer/src/components/activity/activity-clear-completed.test.ts
new file mode 100644
index 00000000000..3723563d143
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-clear-completed.test.ts
@@ -0,0 +1,362 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { RetainedAgentEntry } from '@/store/slices/agent-status'
+import type { ActivityEvent, AgentPaneThread } from './activity-thread-types'
+import { makeTab, makeWorktree } from './ActivityPrototypePage-test-fixtures'
+
+const mockStore = vi.hoisted(() => {
+ const state = {
+ activityClearedAtByPaneKey: {} as Record,
+ agentStatusByPaneKey: {} as Record,
+ retainedAgentsByPaneKey: {} as Record,
+ retentionSuppressedPaneKeys: {} as Record,
+ applyActivityClearedAt: vi.fn((patch: Record) => {
+ const next = { ...state.activityClearedAtByPaneKey }
+ for (const [key, value] of Object.entries(patch)) {
+ if (value === null) {
+ delete next[key]
+ } else {
+ next[key] = value
+ }
+ }
+ state.activityClearedAtByPaneKey = next
+ }),
+ dismissRetainedAgents: vi.fn((paneKeys: readonly string[]) => {
+ const next = { ...state.retainedAgentsByPaneKey }
+ for (const key of paneKeys) {
+ if (state.agentStatusByPaneKey[key]) {
+ state.retentionSuppressedPaneKeys[key] = true
+ }
+ delete next[key]
+ }
+ state.retainedAgentsByPaneKey = next
+ }),
+ clearRetentionSuppressedPaneKeys: vi.fn((paneKeys: string[]) => {
+ for (const key of paneKeys) {
+ delete state.retentionSuppressedPaneKeys[key]
+ }
+ }),
+ retainAgents: vi.fn((entries: RetainedAgentEntry[]) => {
+ const next = { ...state.retainedAgentsByPaneKey }
+ for (const retained of entries) {
+ next[retained.entry.paneKey] = retained
+ }
+ state.retainedAgentsByPaneKey = next
+ })
+ }
+ return state
+})
+
+const toastSpy = vi.hoisted(() => vi.fn())
+
+vi.mock('@/store', () => ({
+ useAppStore: { getState: () => mockStore }
+}))
+vi.mock('sonner', () => ({ toast: toastSpy }))
+
+import {
+ CLEAR_COMPLETED_EVICTION_FALLBACK_MS,
+ clearCompletedActivity,
+ flushPendingClearCompletedEvictions,
+ isClearableActivityThread,
+ planClearCompletedActivity
+} from './activity-clear-completed'
+
+function makeThread(paneKey: string, overrides: Partial = {}): AgentPaneThread {
+ return {
+ paneKey,
+ tab: makeTab(),
+ worktree: makeWorktree(),
+ repo: null,
+ currentAgentState: null,
+ currentAgentEntry: null,
+ latestEvent: null,
+ latestTimestamp: 5_000,
+ agentType: 'claude',
+ unread: false,
+ paneTitle: `Agent ${paneKey}`,
+ responsePreview: '',
+ events: [],
+ ...overrides
+ }
+}
+
+function doneEvent(interrupted: boolean): ActivityEvent {
+ return {
+ id: 'evt',
+ state: 'done',
+ timestamp: 5_000,
+ worktree: makeWorktree(),
+ repo: null,
+ entry: { interrupted } as ActivityEvent['entry'],
+ tab: makeTab(),
+ agentType: 'claude',
+ agentAlive: false,
+ unread: false
+ }
+}
+
+const workingThread = makeThread('t-working:1', { currentAgentState: 'working' })
+const blockedThread = makeThread('t-blocked:1', { currentAgentState: 'blocked' })
+const waitingThread = makeThread('t-waiting:1', { currentAgentState: 'waiting' })
+const doneThread = makeThread('t-done:1', { latestEvent: doneEvent(false) })
+const interruptedThread = makeThread('t-interrupted:1', { latestEvent: doneEvent(true) })
+
+function makeRetained(paneKey: string): RetainedAgentEntry {
+ return {
+ entry: {
+ state: 'done',
+ prompt: 'retained run',
+ updatedAt: 5_000,
+ stateStartedAt: 5_000,
+ paneKey,
+ stateHistory: [],
+ agentType: 'claude'
+ },
+ worktreeId: 'wt-1',
+ tab: makeTab(),
+ agentType: 'claude',
+ startedAt: 5_000
+ }
+}
+
+describe('isClearableActivityThread', () => {
+ it('clears only completed and interrupted threads', () => {
+ expect(isClearableActivityThread(doneThread)).toBe(true)
+ expect(isClearableActivityThread(interruptedThread)).toBe(true)
+ expect(isClearableActivityThread(workingThread)).toBe(false)
+ expect(isClearableActivityThread(blockedThread)).toBe(false)
+ expect(isClearableActivityThread(waitingThread)).toBe(false)
+ })
+})
+
+describe('clearCompletedActivity', () => {
+ beforeEach(() => {
+ mockStore.activityClearedAtByPaneKey = {}
+ mockStore.agentStatusByPaneKey = {}
+ mockStore.retainedAgentsByPaneKey = { 't-done:1': makeRetained('t-done:1') }
+ mockStore.retentionSuppressedPaneKeys = {}
+ vi.stubGlobal('window', {
+ api: { agentStatus: { dropPersisted: vi.fn(), dropPersistedBatch: vi.fn() } }
+ })
+ })
+
+ afterEach(() => {
+ // Drain any eviction left pending by a test that never closed its toast.
+ flushPendingClearCompletedEvictions()
+ vi.clearAllMocks()
+ vi.unstubAllGlobals()
+ })
+
+ function lastToastOptions(): {
+ action: { label: string; onClick: () => void }
+ onDismiss: () => void
+ onAutoClose: () => void
+ } {
+ return toastSpy.mock.calls.at(-1)?.[1]
+ }
+
+ it('plans cutoffs and retained removals for completed threads only', () => {
+ const plan = planClearCompletedActivity(
+ [workingThread, blockedThread, doneThread, interruptedThread],
+ mockStore
+ )
+ expect(plan.clearedThreadCount).toBe(2)
+ expect(plan.cutoffPatch).toEqual({ 't-done:1': 5_000, 't-interrupted:1': 5_000 })
+ expect(plan.restorePatch).toEqual({ 't-done:1': null, 't-interrupted:1': null })
+ expect(plan.retainedSnapshots.map((r) => r.entry.paneKey)).toEqual(['t-done:1'])
+ })
+
+ it('stamps cutoffs, dismisses retained snapshots, and defers the disk drop to toast close', () => {
+ const cleared = clearCompletedActivity([workingThread, doneThread, interruptedThread])
+ expect(cleared).toBe(true)
+ expect(mockStore.activityClearedAtByPaneKey).toEqual({
+ 't-done:1': 5_000,
+ 't-interrupted:1': 5_000
+ })
+ expect(mockStore.dismissRetainedAgents).toHaveBeenCalledWith(['t-done:1'])
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+
+ lastToastOptions().onAutoClose()
+ expect(drop).toHaveBeenCalledTimes(1)
+ expect(drop).toHaveBeenCalledWith([
+ expect.objectContaining({ paneKey: 't-done:1', receivedAt: 5_000, stateStartedAt: 5_000 })
+ ])
+ // A later dismiss must not double-drop.
+ lastToastOptions().onDismiss()
+ expect(drop).toHaveBeenCalledTimes(1)
+ })
+
+ it('undo restores prior cutoffs and re-retains snapshots, and skips the disk drop', () => {
+ mockStore.activityClearedAtByPaneKey = { 't-done:1': 1_111 }
+ clearCompletedActivity([doneThread, interruptedThread])
+ expect(mockStore.activityClearedAtByPaneKey).toEqual({
+ 't-done:1': 5_000,
+ 't-interrupted:1': 5_000
+ })
+ expect(mockStore.retainedAgentsByPaneKey['t-done:1']).toBeUndefined()
+
+ lastToastOptions().action.onClick()
+ expect(mockStore.activityClearedAtByPaneKey).toEqual({ 't-done:1': 1_111 })
+ expect(mockStore.retainedAgentsByPaneKey['t-done:1']).toBeDefined()
+
+ lastToastOptions().onAutoClose()
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+ })
+
+ it('undo restores a completed live row and removes the suppressor created by clear', () => {
+ const retained = mockStore.retainedAgentsByPaneKey['t-done:1']
+ mockStore.agentStatusByPaneKey['t-done:1'] = retained.entry
+ mockStore.activityClearedAtByPaneKey = { 't-done:1': 1_111 }
+
+ clearCompletedActivity([doneThread])
+ expect(mockStore.activityClearedAtByPaneKey['t-done:1']).toBe(5_000)
+ expect(mockStore.retentionSuppressedPaneKeys['t-done:1']).toBe(true)
+
+ lastToastOptions().action.onClick()
+
+ expect(mockStore.activityClearedAtByPaneKey['t-done:1']).toBe(1_111)
+ expect(mockStore.retentionSuppressedPaneKeys['t-done:1']).toBeUndefined()
+ expect(mockStore.retainedAgentsByPaneKey['t-done:1']).toBeUndefined()
+ })
+
+ it('undo removes the suppressor even after an identity-only live entry replacement', () => {
+ // A runtime orchestration merge replaces the live entry object without a state
+ // change; the suppressor undo must key on the turn, not on object identity.
+ const retained = mockStore.retainedAgentsByPaneKey['t-done:1']
+ mockStore.agentStatusByPaneKey['t-done:1'] = retained.entry
+
+ clearCompletedActivity([doneThread])
+ expect(mockStore.retentionSuppressedPaneKeys['t-done:1']).toBe(true)
+ mockStore.agentStatusByPaneKey['t-done:1'] = { ...retained.entry }
+
+ lastToastOptions().action.onClick()
+
+ expect(mockStore.retentionSuppressedPaneKeys['t-done:1']).toBeUndefined()
+ })
+
+ it('undo keeps the suppressor when the live row has moved to a new turn', () => {
+ const retained = mockStore.retainedAgentsByPaneKey['t-done:1']
+ mockStore.agentStatusByPaneKey['t-done:1'] = retained.entry
+
+ clearCompletedActivity([doneThread])
+ mockStore.agentStatusByPaneKey['t-done:1'] = {
+ ...retained.entry,
+ stateStartedAt: retained.entry.stateStartedAt + 1
+ }
+
+ lastToastOptions().action.onClick()
+
+ expect(mockStore.retentionSuppressedPaneKeys['t-done:1']).toBe(true)
+ })
+
+ it('does not restore a cleared snapshot over a newer retained run', () => {
+ clearCompletedActivity([doneThread])
+ const newer = makeRetained('t-done:1')
+ newer.entry.prompt = 'newer run'
+ mockStore.retainedAgentsByPaneKey['t-done:1'] = newer
+
+ lastToastOptions().action.onClick()
+
+ expect(mockStore.retainedAgentsByPaneKey['t-done:1']).toBe(newer)
+ expect(mockStore.activityClearedAtByPaneKey['t-done:1']).toBeUndefined()
+ })
+
+ it('stamps a real cutoff for a thread with no usable timestamp', () => {
+ // A zero cutoff is dropped by the hydrate sanitizer and the clear would replay after restart.
+ const unstamped = makeThread('t-done:1', { latestEvent: doneEvent(false), latestTimestamp: 0 })
+ const plan = planClearCompletedActivity([unstamped], mockStore, 42_000)
+ expect(plan.cutoffPatch).toEqual({ 't-done:1': 42_000 })
+ })
+
+ it('evicts after the fallback window when no toast close callback ever fires', () => {
+ vi.useFakeTimers()
+ try {
+ clearCompletedActivity([doneThread])
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+
+ vi.advanceTimersByTime(CLEAR_COMPLETED_EVICTION_FALLBACK_MS)
+ expect(drop).toHaveBeenCalledTimes(1)
+
+ lastToastOptions().onDismiss()
+ expect(drop).toHaveBeenCalledTimes(1)
+ } finally {
+ vi.useRealTimers()
+ }
+ })
+
+ it('undo cancels the fallback eviction timer', () => {
+ vi.useFakeTimers()
+ try {
+ clearCompletedActivity([doneThread])
+ lastToastOptions().action.onClick()
+ vi.advanceTimersByTime(CLEAR_COMPLETED_EVICTION_FALLBACK_MS)
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+ } finally {
+ vi.useRealTimers()
+ }
+ })
+
+ it('falls back to per-identity drops when the batch API is absent', () => {
+ const dropOne = vi.fn()
+ vi.stubGlobal('window', { api: { agentStatus: { dropPersisted: dropOne } } })
+ clearCompletedActivity([doneThread])
+ lastToastOptions().onAutoClose()
+ expect(dropOne).toHaveBeenCalledTimes(1)
+ })
+
+ it('does nothing when no thread is clearable', () => {
+ expect(clearCompletedActivity([workingThread, blockedThread])).toBe(false)
+ expect(toastSpy).not.toHaveBeenCalled()
+ expect(mockStore.applyActivityClearedAt).not.toHaveBeenCalled()
+ })
+
+ it('pagehide flush evicts a clear whose undo toast is still open', () => {
+ clearCompletedActivity([doneThread])
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+
+ // Quit/reload path: the toast's close callbacks never fire.
+ flushPendingClearCompletedEvictions()
+ expect(drop).toHaveBeenCalledTimes(1)
+
+ // The flushed eviction is consumed; later toast close must not double-drop.
+ lastToastOptions().onAutoClose()
+ expect(drop).toHaveBeenCalledTimes(1)
+ })
+
+ it('pagehide flush skips a clear that was undone', () => {
+ clearCompletedActivity([doneThread])
+ lastToastOptions().action.onClick()
+ flushPendingClearCompletedEvictions()
+ const drop = (
+ window as unknown as {
+ api: { agentStatus: { dropPersistedBatch: ReturnType } }
+ }
+ ).api.agentStatus.dropPersistedBatch
+ expect(drop).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-clear-completed.ts b/src/renderer/src/components/activity/activity-clear-completed.ts
new file mode 100644
index 00000000000..72eee3ea4af
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-clear-completed.ts
@@ -0,0 +1,206 @@
+import { toast } from 'sonner'
+import { useAppStore } from '@/store'
+import { translate } from '@/i18n/i18n'
+import type { RetainedAgentEntry } from '@/store/slices/agent-status'
+import type { AgentStatusCacheIdentity } from '../../../../shared/agent-status-types'
+import { threadStatusGroupId } from './activity-thread-grouping'
+import type { AgentPaneThread } from './activity-thread-types'
+
+export type ClearCompletedActivityPlan = {
+ /** Panes whose activity gets a cleared-at cutoff stamped. */
+ cutoffPatch: Record
+ /** Exact prior cutoff values (or null when absent) so undo restores byte-for-byte. */
+ restorePatch: Record
+ /** Retained snapshots removed by the clear; undo re-retains them verbatim. */
+ retainedSnapshots: RetainedAgentEntry[]
+ /** Exact status identities cleared so deferred disk eviction cannot remove a later run. */
+ cacheIdentities: AgentStatusCacheIdentity[]
+ clearedThreadCount: number
+}
+
+/** A thread is clearable when it needs nothing from the user: completed or interrupted,
+ * with no fresh live working/monitoring/blocked/waiting state. */
+export function isClearableActivityThread(thread: AgentPaneThread): boolean {
+ const groupId = threadStatusGroupId(thread)
+ return groupId === 'done' || groupId === 'interrupted'
+}
+
+export function planClearCompletedActivity(
+ threads: readonly AgentPaneThread[],
+ state: {
+ activityClearedAtByPaneKey: Record
+ retainedAgentsByPaneKey: Record
+ },
+ now: number = Date.now()
+): ClearCompletedActivityPlan {
+ const cutoffPatch: Record = {}
+ const restorePatch: Record = {}
+ const retainedSnapshots: RetainedAgentEntry[] = []
+ const cacheIdentities: AgentStatusCacheIdentity[] = []
+ let clearedThreadCount = 0
+ for (const thread of threads) {
+ if (!isClearableActivityThread(thread)) {
+ continue
+ }
+ clearedThreadCount += 1
+ const previousCutoff = state.activityClearedAtByPaneKey[thread.paneKey] ?? null
+ const latestCutoff = Math.max(previousCutoff ?? 0, thread.latestTimestamp)
+ // Why `now` for an unstamped thread: the hydrate sanitizer drops non-positive cutoffs, so a
+ // zero cutoff would replay the cleared thread after restart.
+ cutoffPatch[thread.paneKey] = latestCutoff > 0 ? latestCutoff : now
+ restorePatch[thread.paneKey] = previousCutoff
+ const retained = state.retainedAgentsByPaneKey[thread.paneKey]
+ if (retained) {
+ retainedSnapshots.push(retained)
+ const entry = retained.entry
+ // updatedAt mirrors the wire receivedAt; renderer-enriched fields (connectionId,
+ // worktreeId) diverge from main's cache and are deliberately excluded.
+ cacheIdentities.push({
+ paneKey: thread.paneKey,
+ receivedAt: entry.updatedAt,
+ stateStartedAt: entry.stateStartedAt
+ })
+ }
+ }
+ return { cutoffPatch, restorePatch, retainedSnapshots, cacheIdentities, clearedThreadCount }
+}
+
+// Deferred evictions whose undo toast is still open; flushed on pagehide because the toast's
+// close callbacks never fire on quit/reload, which would let cleared rows replay next launch.
+const pendingDiskEvictions = new Set<() => void>()
+export function flushPendingClearCompletedEvictions(): void {
+ // Set iteration tolerates the self-delete each evict() performs.
+ for (const evict of pendingDiskEvictions) {
+ evict()
+ }
+}
+if (typeof window !== 'undefined') {
+ window.addEventListener('pagehide', flushPendingClearCompletedEvictions)
+}
+
+// Why a fallback: sonner only fires onDismiss/onAutoClose for the toast's own close paths; a
+// `toast.dismiss()` from another caller leaves the eviction pending until pagehide.
+export const CLEAR_COMPLETED_EVICTION_FALLBACK_MS = 60_000
+
+function evictPersistedStatuses(identities: readonly AgentStatusCacheIdentity[]): void {
+ const api = window.api?.agentStatus
+ if (!api || identities.length === 0) {
+ return
+ }
+ if (api.dropPersistedBatch) {
+ api.dropPersistedBatch(identities)
+ return
+ }
+ for (const identity of identities) {
+ api.dropPersisted?.(identity)
+ }
+}
+
+/**
+ * Clear completed/interrupted activity threads with an undo window.
+ *
+ * Live agent status, resume identity, and attention/working rows are untouched:
+ * clearing stamps per-pane cutoffs (persisted UI) and removes retained completed
+ * snapshots. The identity-checked main-process cache eviction is deferred until
+ * the undo toast closes so Undo can restore everything losslessly.
+ */
+export function clearCompletedActivity(threads: readonly AgentPaneThread[]): boolean {
+ const state = useAppStore.getState()
+ const plan = planClearCompletedActivity(threads, state)
+ if (plan.clearedThreadCount === 0) {
+ return false
+ }
+ state.applyActivityClearedAt(plan.cutoffPatch)
+ // Why turn timestamps, not entry identity: a runtime orchestration merge replaces the live
+ // entry object without a state change (setRuntimeAgentOrchestrationByPaneKey), and an
+ // identity check would then strand the clear-planted suppressor past Undo, losing the run.
+ const introducedSuppressorLiveTurns = new Map(
+ plan.retainedSnapshots.flatMap((retained) => {
+ const paneKey = retained.entry.paneKey
+ const liveEntry = state.agentStatusByPaneKey[paneKey]
+ return liveEntry && !state.retentionSuppressedPaneKeys[paneKey]
+ ? ([[paneKey, liveEntry.stateStartedAt]] as const)
+ : []
+ })
+ )
+ state.dismissRetainedAgents(plan.retainedSnapshots.map((retained) => retained.entry.paneKey))
+
+ let undone = false
+ let dropped = false
+ let fallbackTimer: ReturnType | null = null
+ const dropRetainedFromDiskCache = (): void => {
+ pendingDiskEvictions.delete(dropRetainedFromDiskCache)
+ if (fallbackTimer !== null) {
+ clearTimeout(fallbackTimer)
+ fallbackTimer = null
+ }
+ if (undone || dropped) {
+ return
+ }
+ dropped = true
+ evictPersistedStatuses(plan.cacheIdentities)
+ }
+ pendingDiskEvictions.add(dropRetainedFromDiskCache)
+ fallbackTimer = setTimeout(dropRetainedFromDiskCache, CLEAR_COMPLETED_EVICTION_FALLBACK_MS)
+ toast(
+ plan.clearedThreadCount === 1
+ ? translate('auto.components.activity.clearCompleted.clearedOne', 'Cleared 1 completed agent')
+ : translate(
+ 'auto.components.activity.clearCompleted.clearedMany',
+ 'Cleared {{count}} completed agents',
+ { count: plan.clearedThreadCount }
+ ),
+ {
+ action: {
+ label: translate('auto.components.activity.clearCompleted.undo', 'Undo'),
+ onClick: () => {
+ undone = true
+ pendingDiskEvictions.delete(dropRetainedFromDiskCache)
+ if (fallbackTimer !== null) {
+ clearTimeout(fallbackTimer)
+ fallbackTimer = null
+ }
+ const current = useAppStore.getState()
+ const retainedByPaneKey = new Map(
+ plan.retainedSnapshots.map((retained) => [retained.entry.paneKey, retained])
+ )
+ const restorePatch: Record = {}
+ const snapshotsToRestore: RetainedAgentEntry[] = []
+ const suppressorPaneKeysToClear: string[] = []
+ for (const paneKey of Object.keys(plan.restorePatch)) {
+ const currentLive = current.agentStatusByPaneKey?.[paneKey]
+ const currentRetained = current.retainedAgentsByPaneKey[paneKey]
+ const clearedSnapshot = retainedByPaneKey.get(paneKey)
+ const cutoffStillOwned =
+ current.activityClearedAtByPaneKey[paneKey] === plan.cutoffPatch[paneKey]
+ if (cutoffStillOwned) {
+ restorePatch[paneKey] = plan.restorePatch[paneKey] ?? null
+ }
+ if (
+ cutoffStillOwned &&
+ introducedSuppressorLiveTurns.has(paneKey) &&
+ currentLive?.stateStartedAt === introducedSuppressorLiveTurns.get(paneKey) &&
+ current.retentionSuppressedPaneKeys[paneKey]
+ ) {
+ suppressorPaneKeysToClear.push(paneKey)
+ }
+ if (currentLive || (currentRetained && currentRetained !== clearedSnapshot)) {
+ continue
+ }
+ if (clearedSnapshot && !currentRetained) {
+ snapshotsToRestore.push(clearedSnapshot)
+ }
+ }
+ current.applyActivityClearedAt(restorePatch)
+ current.clearRetentionSuppressedPaneKeys(suppressorPaneKeysToClear)
+ if (snapshotsToRestore.length > 0) {
+ current.retainAgents(snapshotsToRestore)
+ }
+ }
+ },
+ onDismiss: dropRetainedFromDiskCache,
+ onAutoClose: dropRetainedFromDiskCache
+ }
+ )
+ return true
+}
diff --git a/src/renderer/src/components/activity/activity-event-build-cache.ts b/src/renderer/src/components/activity/activity-event-build-cache.ts
new file mode 100644
index 00000000000..09f713c5170
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-build-cache.ts
@@ -0,0 +1,129 @@
+import { entryWithRuntimeOrchestration } from '../sidebar/worktree-agent-row-orchestration'
+import type {
+ AgentStatusEntry,
+ AgentStatusOrchestrationContext,
+ AgentType
+} from '../../../../shared/agent-status-types'
+import type { Repo } from '../../../../shared/repo-types'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import type {
+ ActivityEvent,
+ ActivityLiveAgentSnapshot,
+ ActivityLiveAgentState
+} from './activity-thread-types'
+import { buildPaneActivityEvents } from './activity-pane-events'
+
+type PaneActivityCacheEntry = {
+ source: unknown
+ orchestration: AgentStatusOrchestrationContext | undefined
+ acknowledgedAt: number
+ clearedAt: number
+ worktree: Worktree
+ repo: Repo | null
+ tab: TerminalTab
+ events: ActivityEvent[]
+ live: ActivityLiveAgentSnapshot | null
+ rowEntry: AgentStatusEntry
+}
+
+export type ActivityEventBuildCache = {
+ panes: Map
+}
+
+export function createActivityEventBuildCache(): ActivityEventBuildCache {
+ return { panes: new Map() }
+}
+
+export type PaneBuildRequest = {
+ cacheKey: string
+ source: unknown
+ entry: AgentStatusEntry
+ orchestration: AgentStatusOrchestrationContext | undefined
+ worktree: Worktree
+ repo: Repo | null
+ tab: TerminalTab
+ agentType: AgentType
+ agentAlive: boolean
+ acknowledgedAt: number
+ clearedAt: number
+ migrationUnsupportedPtyId?: string
+ liveState: ActivityLiveAgentState | null
+}
+
+export function resolvePaneBuild(
+ request: PaneBuildRequest,
+ cache: ActivityEventBuildCache | undefined,
+ seenCacheKeys: Set | null
+): { events: ActivityEvent[]; live: ActivityLiveAgentSnapshot | null } {
+ seenCacheKeys?.add(request.cacheKey)
+ const cached = cache?.panes.get(request.cacheKey)
+ const inputsUnchanged =
+ cached !== undefined &&
+ cached.source === request.source &&
+ cached.orchestration === request.orchestration &&
+ cached.acknowledgedAt === request.acknowledgedAt &&
+ cached.clearedAt === request.clearedAt &&
+ cached.worktree === request.worktree &&
+ cached.repo === request.repo &&
+ cached.tab === request.tab
+ const rowEntry = inputsUnchanged
+ ? cached.rowEntry
+ : entryWithRuntimeOrchestration(
+ request.entry,
+ request.orchestration ? { [request.entry.paneKey]: request.orchestration } : undefined
+ )
+
+ const liveTimestamp = rowEntry.stateStartedAt
+ const liveMatchesCache =
+ inputsUnchanged &&
+ (request.liveState === null
+ ? cached.live === null
+ : cached.live !== null &&
+ cached.live.state === request.liveState &&
+ cached.live.timestamp === liveTimestamp)
+
+ if (inputsUnchanged && liveMatchesCache) {
+ return { events: cached.events, live: cached.live }
+ }
+
+ const events = inputsUnchanged
+ ? cached.events
+ : buildPaneActivityEvents({
+ entry: rowEntry,
+ worktree: request.worktree,
+ repo: request.repo,
+ tab: request.tab,
+ agentType: request.agentType,
+ agentAlive: request.agentAlive,
+ acknowledgedAt: request.acknowledgedAt,
+ clearedAt: request.clearedAt,
+ migrationUnsupportedPtyId: request.migrationUnsupportedPtyId
+ })
+ const live: ActivityLiveAgentSnapshot | null =
+ request.liveState === null
+ ? null
+ : {
+ state: request.liveState,
+ timestamp: liveTimestamp,
+ worktree: request.worktree,
+ repo: request.repo,
+ entry: rowEntry,
+ tab: request.tab,
+ agentType: request.agentType
+ }
+
+ cache?.panes.set(request.cacheKey, {
+ source: request.source,
+ orchestration: request.orchestration,
+ acknowledgedAt: request.acknowledgedAt,
+ clearedAt: request.clearedAt,
+ worktree: request.worktree,
+ repo: request.repo,
+ tab: request.tab,
+ events,
+ live,
+ rowEntry
+ })
+ return { events, live }
+}
diff --git a/src/renderer/src/components/activity/activity-event-builder-agent-context.test.ts b/src/renderer/src/components/activity/activity-event-builder-agent-context.test.ts
new file mode 100644
index 00000000000..4f876eb5824
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder-agent-context.test.ts
@@ -0,0 +1,165 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import type { Tab } from '../../../../shared/tab-types'
+import {
+ makeRepo,
+ makeWorkingEntryWithoutHistory,
+ makeWorktree,
+ PANE_KEY
+} from './ActivityPrototypePage-test-fixtures'
+import { buildActivityEvents } from './activity-event-builder'
+
+function build(args: {
+ entry: AgentStatusEntry
+ unifiedTabs?: Tab[]
+}): ReturnType {
+ const repo = makeRepo()
+ const worktree = makeWorktree()
+ return buildActivityEvents({
+ agentStatusByPaneKey: { [PANE_KEY]: args.entry },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [worktree.id]: [] },
+ unifiedTabsByWorktree: { [worktree.id]: args.unifiedTabs ?? [] },
+ worktreeMap: new Map([[worktree.id, worktree]]),
+ repoMap: new Map([[repo.id, repo]]),
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+}
+
+describe('activity event agent contexts', () => {
+ it('builds a live thread context from a unified structured-agent tab', () => {
+ const structuredTab = {
+ id: 'tab-1',
+ entityId: 'session-1',
+ groupId: 'group-1',
+ worktreeId: 'wt-1',
+ executionHostId: 'local',
+ contentType: 'agent-session',
+ label: 'Codex chat',
+ customLabel: null,
+ color: null,
+ sortOrder: 0,
+ createdAt: 1,
+ agentSessionAgent: 'codex'
+ } satisfies Tab
+
+ const result = build({
+ entry: makeWorkingEntryWithoutHistory(),
+ unifiedTabs: [structuredTab]
+ })
+
+ expect(result.liveAgentByPaneKey[PANE_KEY]).toMatchObject({
+ state: 'working',
+ worktree: { id: 'wt-1' },
+ tab: { id: 'tab-1', ptyId: null, title: 'Codex chat' }
+ })
+ })
+
+ it('uses direct worktree attribution before an agent tab reaches the renderer', () => {
+ const result = build({
+ entry: {
+ ...makeWorkingEntryWithoutHistory(),
+ worktreeId: 'wt-1'
+ }
+ })
+
+ expect(result.liveAgentByPaneKey[PANE_KEY]).toMatchObject({
+ state: 'working',
+ worktree: { id: 'wt-1' },
+ tab: { id: 'tab-1', worktreeId: 'wt-1', ptyId: null }
+ })
+ })
+
+ it('preserves a unified structured session remote-runtime owner', () => {
+ const localRepo = makeRepo()
+ const runtimeRepo = {
+ ...makeRepo(),
+ executionHostId: 'runtime:env-1' as const,
+ displayName: 'Runtime repo'
+ }
+ const localWorktree = makeWorktree()
+ const runtimeWorktree = {
+ ...makeWorktree(),
+ hostId: 'runtime:env-1' as const,
+ runtimeOwnerEnvironmentId: 'env-1',
+ displayName: 'Runtime worktree'
+ }
+ const structuredTab = {
+ id: 'tab-1',
+ entityId: 'session-1',
+ groupId: 'group-1',
+ worktreeId: 'wt-1',
+ executionHostId: 'runtime:env-1',
+ contentType: 'agent-session',
+ label: 'Remote Codex chat',
+ customLabel: null,
+ color: null,
+ sortOrder: 0,
+ createdAt: 1,
+ agentSessionAgent: 'codex'
+ } satisfies Tab
+ const resolveWorktree = vi.fn((_worktreeId, executionHostId) =>
+ executionHostId === 'runtime:env-1' ? runtimeWorktree : localWorktree
+ )
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {
+ [PANE_KEY]: { ...makeWorkingEntryWithoutHistory(), connectionId: null }
+ },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [localWorktree.id]: [] },
+ unifiedTabsByWorktree: { [localWorktree.id]: [structuredTab] },
+ worktreeMap: new Map([[localWorktree.id, localWorktree]]),
+ repoMap: new Map([[localRepo.id, localRepo]]),
+ repos: [localRepo, runtimeRepo],
+ resolveWorktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(resolveWorktree).toHaveBeenCalledWith('wt-1', 'runtime:env-1')
+ expect(result.liveAgentByPaneKey[PANE_KEY]?.worktree).toBe(runtimeWorktree)
+ expect(result.liveAgentByPaneKey[PANE_KEY]?.repo).toBe(runtimeRepo)
+ })
+
+ it('preserves an early worktree-attributed SSH owner before its tab arrives', () => {
+ const localRepo = makeRepo()
+ const remoteRepo = {
+ ...makeRepo(),
+ connectionId: 'builder',
+ displayName: 'SSH repo'
+ }
+ const localWorktree = makeWorktree()
+ const remoteWorktree = {
+ ...makeWorktree(),
+ hostId: 'ssh:builder' as const,
+ displayName: 'SSH worktree'
+ }
+ const resolveWorktree = vi.fn((_worktreeId, executionHostId) =>
+ executionHostId === 'ssh:builder' ? remoteWorktree : localWorktree
+ )
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {
+ [PANE_KEY]: {
+ ...makeWorkingEntryWithoutHistory(),
+ worktreeId: 'wt-1',
+ connectionId: 'builder'
+ }
+ },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [localWorktree.id]: [] },
+ worktreeMap: new Map([[localWorktree.id, localWorktree]]),
+ repoMap: new Map([[localRepo.id, localRepo]]),
+ repos: [localRepo, remoteRepo],
+ resolveWorktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(resolveWorktree).toHaveBeenCalledWith('wt-1', 'ssh:builder')
+ expect(result.liveAgentByPaneKey[PANE_KEY]?.worktree).toBe(remoteWorktree)
+ expect(result.liveAgentByPaneKey[PANE_KEY]?.repo).toBe(remoteRepo)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-event-builder-context.ts b/src/renderer/src/components/activity/activity-event-builder-context.ts
new file mode 100644
index 00000000000..3fdd2584fef
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder-context.ts
@@ -0,0 +1,182 @@
+import { findIndexedRepoOwnerForHost } from '@/lib/worktree-runtime-owner-index'
+import { getRemoteRuntimePtyEnvironmentId } from '@/runtime/runtime-terminal-stream'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import {
+ LOCAL_EXECUTION_HOST_ID,
+ toRuntimeExecutionHostId,
+ toSshExecutionHostId,
+ type ExecutionHostId
+} from '../../../../shared/execution-host'
+import type { Repo } from '../../../../shared/repo-types'
+import { parseAppSshPtyId } from '../../../../shared/ssh-pty-id'
+import type { Tab } from '../../../../shared/tab-types'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import {
+ effectiveWorktreeAgentRowStartedAt,
+ tabFromWorktreeAttributedStatusEntry
+} from '../sidebar/worktree-agent-row-fallback-tab'
+import type { BuildActivityEventsArgs } from './activity-event-builder'
+import { standaloneActivityWorktree } from './activity-standalone-worktree'
+
+export type ActivityTabContext = { worktreeId: string; tab: TerminalTab }
+export type ActivityEventOwner = { worktree: Worktree; repo: Repo | null; knownWorktree: boolean }
+export type ActivityTabHostIndex = Map>
+
+// Why memoized on the source object: the pane build cache compares `tab` by identity, so a
+// fresh derived object per rebuild would miss the cache for every agent-session and
+// missing-tab row. Upstream keeps the source identity stable while its fields are unchanged.
+const agentSessionTerminalTabs = new WeakMap()
+const attributedTabContexts = new WeakMap()
+
+function terminalTabFromAgentSessionTab(tab: Tab): TerminalTab {
+ const cached = agentSessionTerminalTabs.get(tab)
+ if (cached) {
+ return cached
+ }
+ const derived: TerminalTab = {
+ id: tab.id,
+ ptyId: null,
+ worktreeId: tab.worktreeId,
+ title: tab.customLabel ?? tab.generatedLabel ?? tab.label,
+ customTitle: tab.customLabel,
+ color: tab.color,
+ isPinned: tab.isPinned,
+ sortOrder: tab.sortOrder,
+ createdAt: tab.createdAt
+ }
+ agentSessionTerminalTabs.set(tab, derived)
+ return derived
+}
+
+export function buildActivityTabContext(
+ tabsByWorktree: Record,
+ unifiedTabsByWorktree?: Record
+): Map {
+ const contexts = new Map()
+ for (const [worktreeId, tabs] of Object.entries(tabsByWorktree)) {
+ for (const tab of tabs) {
+ contexts.set(tab.id, { worktreeId, tab })
+ }
+ }
+ for (const [worktreeId, tabs] of Object.entries(unifiedTabsByWorktree ?? {})) {
+ for (const tab of tabs) {
+ if (tab.contentType !== 'agent-session' || contexts.has(tab.id)) {
+ continue
+ }
+ contexts.set(tab.id, { worktreeId, tab: terminalTabFromAgentSessionTab(tab) })
+ }
+ }
+ return contexts
+}
+
+export function attributedActivityTabContext(entry: AgentStatusEntry): ActivityTabContext | null {
+ const cached = attributedTabContexts.get(entry)
+ if (cached !== undefined) {
+ return cached
+ }
+ const tab = tabFromWorktreeAttributedStatusEntry(entry, effectiveWorktreeAgentRowStartedAt(entry))
+ const context = tab ? { worktreeId: tab.worktreeId, tab } : null
+ attributedTabContexts.set(entry, context)
+ return context
+}
+
+export function buildActivityTabHostIndex(
+ unifiedTabsByWorktree?: Record
+): ActivityTabHostIndex {
+ const index: ActivityTabHostIndex = new Map()
+ for (const [worktreeId, tabs] of Object.entries(unifiedTabsByWorktree ?? {})) {
+ for (const tab of tabs) {
+ if (
+ (tab.contentType !== 'terminal' && tab.contentType !== 'agent-session') ||
+ !tab.executionHostId
+ ) {
+ continue
+ }
+ let byTabId = index.get(worktreeId)
+ if (!byTabId) {
+ byTabId = new Map()
+ index.set(worktreeId, byTabId)
+ }
+ const contextTabId = tab.contentType === 'terminal' ? tab.entityId : tab.id
+ const existing = byTabId.get(contextTabId)
+ byTabId.set(
+ contextTabId,
+ existing === undefined || existing === tab.executionHostId ? tab.executionHostId : null
+ )
+ }
+ }
+ return index
+}
+
+function resolveActivityExecutionHostId(
+ context: ActivityTabContext,
+ entry: AgentStatusEntry,
+ terminalPtyId: string | null | undefined,
+ tabHostIndex: ActivityTabHostIndex
+): ExecutionHostId | undefined {
+ const tabHostId = tabHostIndex.get(context.worktreeId)?.get(context.tab.id)
+ if (tabHostId) {
+ return tabHostId
+ }
+ // Why before connectionId: a runtime pane's status entry publishes connectionId: null,
+ // which would otherwise resolve to LOCAL (see dashboard-card-terminal-input's precedent).
+ const runtimeEnvironmentId = getRemoteRuntimePtyEnvironmentId(terminalPtyId ?? '')
+ if (runtimeEnvironmentId) {
+ return toRuntimeExecutionHostId(runtimeEnvironmentId)
+ }
+ if (entry.connectionId !== undefined) {
+ return entry.connectionId ? toSshExecutionHostId(entry.connectionId) : LOCAL_EXECUTION_HOST_ID
+ }
+ const connectionId = parseAppSshPtyId(terminalPtyId ?? '')?.connectionId
+ return connectionId ? toSshExecutionHostId(connectionId) : undefined
+}
+
+export function resolveActivityEventOwner(
+ args: BuildActivityEventsArgs,
+ context: ActivityTabContext,
+ entry: AgentStatusEntry,
+ terminalPtyId: string | null | undefined,
+ tabHostIndex: ActivityTabHostIndex,
+ ownerCache: Map
+): ActivityEventOwner {
+ const executionHostId = resolveActivityExecutionHostId(
+ context,
+ entry,
+ terminalPtyId,
+ tabHostIndex
+ )
+ // Why: resolution runs per pane per rebuild and the miss path scans detected worktrees;
+ // everything below depends only on worktreeId + host, so memoize per build.
+ const ownerCacheKey = `${context.worktreeId}\0${executionHostId ?? ''}`
+ const cached = ownerCache.get(ownerCacheKey)
+ if (cached) {
+ return cached
+ }
+ const resolvedWorktree = args.resolveWorktree?.(context.worktreeId, executionHostId)
+ const mappedWorktree = args.worktreeMap.get(context.worktreeId)
+ const worktree =
+ resolvedWorktree ??
+ mappedWorktree ??
+ standaloneActivityWorktree(context.worktreeId, executionHostId)
+ let repo =
+ executionHostId && args.repos
+ ? findIndexedRepoOwnerForHost(args.repos, worktree.repoId, executionHostId)
+ : null
+ if (!repo && worktree.runtimeOwnerEnvironmentId && args.repos) {
+ repo = findIndexedRepoOwnerForHost(
+ args.repos,
+ worktree.repoId,
+ toRuntimeExecutionHostId(worktree.runtimeOwnerEnvironmentId)
+ )
+ }
+ const owner: ActivityEventOwner = {
+ worktree,
+ repo: repo ?? args.repoMap.get(worktree.repoId) ?? null,
+ knownWorktree: Boolean(
+ resolvedWorktree || mappedWorktree || args.tabsByWorktree[context.worktreeId]
+ )
+ }
+ ownerCache.set(ownerCacheKey, owner)
+ return owner
+}
diff --git a/src/renderer/src/components/activity/activity-event-builder-sources.ts b/src/renderer/src/components/activity/activity-event-builder-sources.ts
new file mode 100644
index 00000000000..1049ed95acf
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder-sources.ts
@@ -0,0 +1,105 @@
+import { migrationUnsupportedToAgentStatusEntry } from '@/lib/migration-unsupported-agent-entry'
+import { parsePaneKey } from '../../../../shared/stable-pane-id'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import type { Repo } from '../../../../shared/repo-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import type { ActivityLiveAgentSnapshot, ActivityEvent } from './activity-thread-types'
+import type { ActivityEventBuildCache } from './activity-event-build-cache'
+import { resolvePaneBuild } from './activity-event-build-cache'
+import type { BuildActivityEventsArgs } from './activity-event-builder'
+
+export function appendUnsupportedAndRetainedEvents(context: {
+ args: BuildActivityEventsArgs
+ cache: ActivityEventBuildCache | undefined
+ seenCacheKeys: Set | null
+ liveAgentByPaneKey: Record
+ tabContext: Map
+ resolveOwner: (
+ context: { worktreeId: string; tab: TerminalTab },
+ entry: AgentStatusEntry,
+ terminalPtyId?: string | null
+ ) => { worktree: Worktree; repo: Repo | null; knownWorktree: boolean }
+ pushPaneEvents: (paneEvents: ActivityEvent[]) => void
+}): void {
+ const {
+ args,
+ cache,
+ seenCacheKeys,
+ liveAgentByPaneKey,
+ tabContext,
+ resolveOwner,
+ pushPaneEvents
+ } = context
+
+ for (const unsupported of Object.values(args.migrationUnsupportedByPtyId ?? {})) {
+ const cacheKey = `unsupported:${unsupported.paneKey ?? unsupported.ptyId}`
+ const cached = cache?.panes.get(cacheKey)
+ const entry =
+ cached?.source === unsupported
+ ? cached.rowEntry
+ : migrationUnsupportedToAgentStatusEntry(unsupported)
+ const parsed = entry ? parsePaneKey(entry.paneKey) : null
+ const tabEntry = parsed ? tabContext.get(parsed.tabId) : null
+ if (!entry || !tabEntry) {
+ continue
+ }
+ const owner = resolveOwner(tabEntry, entry, unsupported.ptyId)
+ const { events: paneEvents, live } = resolvePaneBuild(
+ {
+ cacheKey,
+ source: unsupported,
+ entry,
+ orchestration: undefined,
+ worktree: owner.worktree,
+ repo: owner.repo,
+ tab: tabEntry.tab,
+ agentType: entry.agentType ?? 'unknown',
+ agentAlive: false,
+ acknowledgedAt: args.acknowledgedAgentsByPaneKey[entry.paneKey] ?? 0,
+ clearedAt: args.activityClearedAtByPaneKey?.[entry.paneKey] ?? 0,
+ migrationUnsupportedPtyId: unsupported.ptyId,
+ liveState: 'blocked'
+ },
+ cache,
+ seenCacheKeys
+ )
+ if (live) {
+ liveAgentByPaneKey[entry.paneKey] = live
+ }
+ pushPaneEvents(paneEvents)
+ }
+
+ for (const [paneKey, retained] of Object.entries(args.retainedAgentsByPaneKey)) {
+ if (!parsePaneKey(paneKey)) {
+ continue
+ }
+ const owner = resolveOwner(
+ { worktreeId: retained.worktreeId, tab: retained.tab },
+ retained.entry,
+ retained.tab.ptyId ?? retained.entry.terminalHandle
+ )
+ if (!owner.knownWorktree) {
+ continue
+ }
+ const { events: paneEvents } = resolvePaneBuild(
+ {
+ cacheKey: `retained:${paneKey}`,
+ source: retained,
+ entry: retained.entry,
+ orchestration: args.runtimeAgentOrchestrationByPaneKey?.[paneKey],
+ worktree: owner.worktree,
+ repo: owner.repo,
+ tab: retained.tab,
+ agentType: retained.agentType,
+ agentAlive: false,
+ acknowledgedAt: args.acknowledgedAgentsByPaneKey[paneKey] ?? 0,
+ clearedAt: args.activityClearedAtByPaneKey?.[paneKey] ?? 0,
+ liveState: null
+ },
+ cache,
+ seenCacheKeys
+ )
+ pushPaneEvents(paneEvents)
+ }
+}
diff --git a/src/renderer/src/components/activity/activity-event-builder.bounded-history.test.ts b/src/renderer/src/components/activity/activity-event-builder.bounded-history.test.ts
new file mode 100644
index 00000000000..c6350555584
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder.bounded-history.test.ts
@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest'
+import type {
+ AgentStateHistoryEntry,
+ AgentStatusEntry
+} from '../../../../shared/agent-status-types'
+import { buildActivityEvents, newestActivityHistoryEntries } from './activity-event-builder'
+import { EVENTS_PER_PANE_CAP } from './activity-event-cap'
+import { makeRepo, makeTab, makeWorktree, PANE_KEY } from './ActivityPrototypePage-test-fixtures'
+
+function historyEntry(
+ startedAt: number,
+ state: AgentStateHistoryEntry['state']
+): AgentStateHistoryEntry {
+ return { state, prompt: `prompt-${startedAt}`, startedAt }
+}
+
+function build(args: {
+ entries?: Record
+ activityClearedAtByPaneKey?: Record
+ now?: number
+}) {
+ const repo = makeRepo()
+ const worktree = makeWorktree()
+ const tab = makeTab()
+ return buildActivityEvents({
+ agentStatusByPaneKey: args.entries ?? {},
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [worktree.id]: [tab] },
+ worktreeMap: new Map([[worktree.id, worktree]]),
+ repoMap: new Map([[repo.id, repo]]),
+ acknowledgedAgentsByPaneKey: {},
+ activityClearedAtByPaneKey: args.activityClearedAtByPaneKey,
+ now: args.now ?? 100_000
+ })
+}
+
+describe('newestActivityHistoryEntries', () => {
+ it('takes only the newest cap-many eligible entries without scanning results past the cap', () => {
+ const history: AgentStateHistoryEntry[] = []
+ for (let i = 0; i < 10_000; i += 1) {
+ history.push(historyEntry(i + 1, i % 2 === 0 ? 'done' : 'working'))
+ }
+ const newest = newestActivityHistoryEntries(history, EVENTS_PER_PANE_CAP)
+ expect(newest).toHaveLength(EVENTS_PER_PANE_CAP)
+ // Only done/blocked/waiting are eligible; newest five eligible are the last five even-indexed rows, oldest-first.
+ expect(newest.map((entry) => entry.startedAt)).toEqual([9991, 9993, 9995, 9997, 9999])
+ })
+
+ it('returns fewer entries when eligible history is short', () => {
+ const history = [historyEntry(1, 'working'), historyEntry(2, 'done')]
+ expect(
+ newestActivityHistoryEntries(history, EVENTS_PER_PANE_CAP).map((e) => e.startedAt)
+ ).toEqual([2])
+ })
+})
+
+describe('buildActivityEvents bounded history', () => {
+ it('produces identical visible events for a pane with unbounded history as the per-pane cap allows', () => {
+ const longHistory: AgentStateHistoryEntry[] = []
+ for (let i = 0; i < 1_000; i += 1) {
+ longHistory.push(historyEntry(i + 1, 'done'))
+ }
+ const entry: AgentStatusEntry = {
+ state: 'done',
+ prompt: 'latest',
+ updatedAt: 5_000,
+ stateStartedAt: 5_000,
+ paneKey: PANE_KEY,
+ stateHistory: longHistory,
+ agentType: 'claude'
+ }
+ const { events } = build({ entries: { [PANE_KEY]: entry } })
+ // Per-pane cap holds: newest events only, newest-first ordering preserved.
+ expect(events).toHaveLength(EVENTS_PER_PANE_CAP)
+ expect(events.map((event) => event.timestamp)).toEqual([5_000, 1_000, 999, 998, 997])
+ })
+})
+
+describe('buildActivityEvents cleared cutoff', () => {
+ const doneEntry: AgentStatusEntry = {
+ state: 'done',
+ prompt: 'finish it',
+ updatedAt: 2_000,
+ stateStartedAt: 2_000,
+ paneKey: PANE_KEY,
+ stateHistory: [historyEntry(1_000, 'done')],
+ agentType: 'claude'
+ }
+
+ it('hides events stamped at or before the pane cutoff', () => {
+ const { events } = build({
+ entries: { [PANE_KEY]: doneEntry },
+ activityClearedAtByPaneKey: { [PANE_KEY]: 2_000 }
+ })
+ expect(events).toHaveLength(0)
+ })
+
+ it('keeps events newer than the cutoff', () => {
+ const { events } = build({
+ entries: { [PANE_KEY]: doneEntry },
+ activityClearedAtByPaneKey: { [PANE_KEY]: 1_000 }
+ })
+ expect(events.map((event) => event.timestamp)).toEqual([2_000])
+ })
+
+ it('does not suppress a live working snapshot for a cleared pane', () => {
+ const workingEntry: AgentStatusEntry = {
+ ...doneEntry,
+ state: 'working',
+ updatedAt: 99_000,
+ stateStartedAt: 99_000
+ }
+ const { events, liveAgentByPaneKey } = build({
+ entries: { [PANE_KEY]: workingEntry },
+ activityClearedAtByPaneKey: { [PANE_KEY]: 98_000 },
+ now: 99_500
+ })
+ expect(liveAgentByPaneKey[PANE_KEY]?.state).toBe('working')
+ // The historical done at 1_000 stays hidden by the cutoff.
+ expect(events).toHaveLength(0)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-event-builder.host-ownership.test.ts b/src/renderer/src/components/activity/activity-event-builder.host-ownership.test.ts
new file mode 100644
index 00000000000..51beb6cf1f9
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder.host-ownership.test.ts
@@ -0,0 +1,206 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import { folderWorkspaceKey } from '../../../../shared/workspace-scope'
+import {
+ LEAF_ID,
+ makeRepo,
+ makeRetainedDoneEntry,
+ makeTab,
+ makeWorktree
+} from './ActivityPrototypePage-test-fixtures'
+import { buildActivityEvents } from './activity-event-builder'
+
+const PANE_KEY = `tab-1:${LEAF_ID}`
+
+function doneEntry(connectionId: string | null): AgentStatusEntry {
+ return {
+ state: 'done',
+ prompt: 'Finished task',
+ updatedAt: 2_000,
+ stateStartedAt: 2_000,
+ paneKey: PANE_KEY,
+ tabId: 'tab-1',
+ connectionId,
+ stateHistory: [],
+ agentType: 'claude'
+ }
+}
+
+describe('activity event host ownership', () => {
+ it('uses the status transport host when worktree and repo ids collide', () => {
+ const localRepo = makeRepo()
+ const remoteRepo = { ...makeRepo(), connectionId: 'builder', displayName: 'Remote repo' }
+ const localWorktree = makeWorktree()
+ const remoteWorktree = {
+ ...makeWorktree(),
+ hostId: 'ssh:builder' as const,
+ displayName: 'Remote worktree'
+ }
+ const tab = makeTab()
+ const resolveWorktree = vi.fn((_worktreeId, executionHostId) =>
+ executionHostId === 'ssh:builder' ? remoteWorktree : localWorktree
+ )
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: { [PANE_KEY]: doneEntry('builder') },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [localWorktree.id]: [tab] },
+ worktreeMap: new Map([[localWorktree.id, localWorktree]]),
+ repoMap: new Map([[localRepo.id, localRepo]]),
+ repos: [localRepo, remoteRepo],
+ resolveWorktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(resolveWorktree).toHaveBeenCalledWith(localWorktree.id, 'ssh:builder')
+ expect(result.events[0]?.worktree).toBe(remoteWorktree)
+ expect(result.events[0]?.repo).toBe(remoteRepo)
+ })
+
+ it('uses the mirrored tab host when paired-runtime status is host-local', () => {
+ const localRepo = makeRepo()
+ const runtimeRepo = {
+ ...makeRepo(),
+ executionHostId: 'runtime:env-1' as const,
+ displayName: 'Runtime repo'
+ }
+ const localWorktree = makeWorktree()
+ const runtimeWorktree = {
+ ...makeWorktree(),
+ hostId: 'runtime:env-1' as const,
+ runtimeOwnerEnvironmentId: 'env-1',
+ displayName: 'Runtime worktree'
+ }
+ const tab = makeTab()
+ const resolveWorktree = vi.fn((_worktreeId, executionHostId) =>
+ executionHostId === 'runtime:env-1' ? runtimeWorktree : localWorktree
+ )
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: { [PANE_KEY]: doneEntry(null) },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: { [localWorktree.id]: [tab] },
+ unifiedTabsByWorktree: {
+ [localWorktree.id]: [
+ {
+ id: tab.id,
+ entityId: tab.id,
+ groupId: 'group-1',
+ worktreeId: localWorktree.id,
+ executionHostId: 'runtime:env-1',
+ contentType: 'terminal',
+ label: tab.title,
+ customLabel: null,
+ color: null,
+ sortOrder: 0,
+ createdAt: 1
+ }
+ ]
+ },
+ worktreeMap: new Map([[localWorktree.id, localWorktree]]),
+ repoMap: new Map([[localRepo.id, localRepo]]),
+ repos: [localRepo, runtimeRepo],
+ resolveWorktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(resolveWorktree).toHaveBeenCalledWith(localWorktree.id, 'runtime:env-1')
+ expect(result.events[0]?.worktree).toBe(runtimeWorktree)
+ expect(result.events[0]?.repo).toBe(runtimeRepo)
+ })
+
+ it('keeps retained folder-workspace activity after its terminal tab is gone', () => {
+ const folderWorktree = {
+ ...makeWorktree(),
+ id: folderWorkspaceKey('folder-1'),
+ repoId: 'folder-workspace:group-1',
+ hostId: 'local' as const,
+ displayName: 'Docs folder'
+ }
+ const tab = { ...makeTab(), worktreeId: folderWorktree.id }
+ const retained = makeRetainedDoneEntry(tab)
+ retained.worktreeId = folderWorktree.id
+ retained.entry = doneEntry(null)
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {},
+ retainedAgentsByPaneKey: { [PANE_KEY]: retained },
+ tabsByWorktree: {},
+ worktreeMap: new Map(),
+ repoMap: new Map(),
+ resolveWorktree: (worktreeId, executionHostId) =>
+ worktreeId === folderWorktree.id && executionHostId === 'local'
+ ? folderWorktree
+ : undefined,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(result.events[0]?.worktree).toBe(folderWorktree)
+ expect(result.events[0]?.worktree.displayName).toBe('Docs folder')
+ })
+
+ it('carries migrationUnsupportedPtyId on events built for un-migratable panes', () => {
+ const worktree = makeWorktree()
+ const repo = makeRepo()
+ const tab = makeTab()
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {},
+ retainedAgentsByPaneKey: {},
+ migrationUnsupportedByPtyId: {
+ 'pty-1': {
+ ptyId: 'pty-1',
+ paneKey: PANE_KEY,
+ tabId: tab.id,
+ reason: 'legacy-numeric-pane-key',
+ source: 'local',
+ updatedAt: 1_000
+ }
+ },
+ tabsByWorktree: { [worktree.id]: [tab] },
+ worktreeMap: new Map([[worktree.id, worktree]]),
+ repoMap: new Map([[repo.id, repo]]),
+ resolveWorktree: () => worktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(result.events.length).toBeGreaterThan(0)
+ for (const event of result.events) {
+ expect(event.migrationUnsupportedPtyId).toBe('pty-1')
+ }
+ })
+
+ it('uses the retained terminal handle to preserve runtime host ownership after teardown', () => {
+ const localWorktree = makeWorktree()
+ const runtimeWorktree = {
+ ...makeWorktree(),
+ hostId: 'runtime:env-1' as const,
+ runtimeOwnerEnvironmentId: 'env-1',
+ displayName: 'Runtime worktree'
+ }
+ const tab = { ...makeTab(), ptyId: null }
+ const retained = makeRetainedDoneEntry(tab)
+ retained.entry = { ...doneEntry(null), terminalHandle: 'remote:env-1@@pty-1' }
+ const resolveWorktree = vi.fn((_worktreeId, executionHostId) =>
+ executionHostId === 'runtime:env-1' ? runtimeWorktree : localWorktree
+ )
+
+ const result = buildActivityEvents({
+ agentStatusByPaneKey: {},
+ retainedAgentsByPaneKey: { [PANE_KEY]: retained },
+ tabsByWorktree: {},
+ worktreeMap: new Map([[localWorktree.id, localWorktree]]),
+ repoMap: new Map(),
+ resolveWorktree,
+ acknowledgedAgentsByPaneKey: {},
+ now: 3_000
+ })
+
+ expect(resolveWorktree).toHaveBeenCalledWith(localWorktree.id, 'runtime:env-1')
+ expect(result.events[0]?.worktree).toBe(runtimeWorktree)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-event-builder.identity-reuse.test.ts b/src/renderer/src/components/activity/activity-event-builder.identity-reuse.test.ts
new file mode 100644
index 00000000000..1c1a76aff20
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-event-builder.identity-reuse.test.ts
@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import type { RetainedAgentEntry } from '@/store/slices/agent-status'
+import { makePaneKey } from '../../../../shared/stable-pane-id'
+import {
+ buildActivityEvents,
+ createActivityEventBuildCache,
+ type ActivityEventBuildCache
+} from './activity-event-builder'
+import {
+ buildAgentPaneThreads,
+ createAgentPaneThreadReuseCache,
+ type AgentPaneThreadReuseCache
+} from './activity-thread-builder'
+import {
+ LEAF_ID,
+ LEAF_ID_2,
+ makeRepo,
+ makeTab,
+ makeTabWithIds,
+ makeWorktree
+} from './ActivityPrototypePage-test-fixtures'
+
+const PANE_A = makePaneKey('tab-1', LEAF_ID)
+const PANE_B = makePaneKey('tab-2', LEAF_ID_2)
+const NOW = 100_000
+
+function entry(paneKey: string, overrides: Partial = {}): AgentStatusEntry {
+ return {
+ state: 'done',
+ prompt: `run ${paneKey}`,
+ updatedAt: 50_000,
+ stateStartedAt: 50_000,
+ paneKey,
+ stateHistory: [{ state: 'done', prompt: 'older', startedAt: 10_000 }],
+ agentType: 'claude',
+ ...overrides
+ }
+}
+
+type BuildArgs = Parameters[0]
+
+function makeArgs(overrides: Partial = {}): BuildArgs {
+ const repo = makeRepo()
+ const worktree = makeWorktree()
+ return {
+ agentStatusByPaneKey: {
+ [PANE_A]: entry(PANE_A),
+ [PANE_B]: entry(PANE_B, { state: 'working', stateStartedAt: NOW - 1_000 })
+ },
+ retainedAgentsByPaneKey: {},
+ tabsByWorktree: {
+ [worktree.id]: [makeTab(), makeTabWithIds('tab-2', worktree.id)]
+ },
+ worktreeMap: new Map([[worktree.id, worktree]]),
+ repoMap: new Map([[repo.id, repo]]),
+ acknowledgedAgentsByPaneKey: {},
+ now: NOW,
+ ...overrides
+ }
+}
+
+function buildBoth(
+ args: BuildArgs,
+ eventCache: ActivityEventBuildCache,
+ threadCache: AgentPaneThreadReuseCache
+) {
+ const result = buildActivityEvents(args, eventCache)
+ const threads = buildAgentPaneThreads(
+ { events: result.events, liveAgentByPaneKey: result.liveAgentByPaneKey },
+ threadCache
+ )
+ return { ...result, threads }
+}
+
+function threadByPane(threads: T[], paneKey: string): T | undefined {
+ return threads.find((thread) => thread.paneKey === paneKey)
+}
+
+describe('activity build identity reuse', () => {
+ it('returns identical event, snapshot, thread, and list identities for identical inputs', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const args = makeArgs()
+ const first = buildBoth(args, eventCache, threadCache)
+ const second = buildBoth(args, eventCache, threadCache)
+
+ expect(second.threads).toBe(first.threads)
+ expect(second.events.map((event) => event)).toEqual(first.events.map((event) => event))
+ for (let i = 0; i < first.events.length; i += 1) {
+ expect(second.events[i]).toBe(first.events[i])
+ }
+ expect(second.liveAgentByPaneKey[PANE_B]).toBe(first.liveAgentByPaneKey[PANE_B])
+ })
+
+ it('changes only the written pane; every other thread keeps its identity', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const args = makeArgs()
+ const first = buildBoth(args, eventCache, threadCache)
+
+ const next = makeArgs({
+ agentStatusByPaneKey: {
+ ...args.agentStatusByPaneKey,
+ [PANE_B]: entry(PANE_B, {
+ state: 'working',
+ stateStartedAt: NOW - 1_000,
+ prompt: 'streamed update'
+ })
+ },
+ tabsByWorktree: args.tabsByWorktree,
+ worktreeMap: args.worktreeMap,
+ repoMap: args.repoMap
+ })
+ const second = buildBoth(next, eventCache, threadCache)
+
+ expect(threadByPane(second.threads, PANE_A)).toBe(threadByPane(first.threads, PANE_A))
+ expect(threadByPane(second.threads, PANE_B)).not.toBe(threadByPane(first.threads, PANE_B))
+ expect(second.threads).not.toBe(first.threads)
+ })
+
+ it('an acknowledgement or cleared-cutoff change rebuilds only that pane', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const args = makeArgs()
+ const first = buildBoth(args, eventCache, threadCache)
+
+ const acked = buildBoth(
+ makeArgs({
+ agentStatusByPaneKey: args.agentStatusByPaneKey,
+ tabsByWorktree: args.tabsByWorktree,
+ worktreeMap: args.worktreeMap,
+ repoMap: args.repoMap,
+ acknowledgedAgentsByPaneKey: { [PANE_A]: NOW }
+ }),
+ eventCache,
+ threadCache
+ )
+ expect(threadByPane(acked.threads, PANE_B)).toBe(threadByPane(first.threads, PANE_B))
+ expect(threadByPane(acked.threads, PANE_A)?.unread).toBe(false)
+ expect(threadByPane(first.threads, PANE_A)?.unread).toBe(true)
+
+ const cleared = buildBoth(
+ makeArgs({
+ agentStatusByPaneKey: args.agentStatusByPaneKey,
+ tabsByWorktree: args.tabsByWorktree,
+ worktreeMap: args.worktreeMap,
+ repoMap: args.repoMap,
+ acknowledgedAgentsByPaneKey: { [PANE_A]: NOW },
+ activityClearedAtByPaneKey: { [PANE_A]: NOW }
+ }),
+ eventCache,
+ threadCache
+ )
+ expect(threadByPane(cleared.threads, PANE_B)).toBe(threadByPane(first.threads, PANE_B))
+ expect(threadByPane(cleared.threads, PANE_A)).toBeUndefined()
+ })
+
+ it('freshness decay refreshes the live snapshot without churning event identities', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const args = makeArgs()
+ const first = buildBoth(args, eventCache, threadCache)
+ expect(first.liveAgentByPaneKey[PANE_B]?.state).toBe('working')
+
+ // Same inputs much later: the working turn is stale now, so the snapshot drops.
+ const decayed = buildBoth(
+ makeArgs({ ...args, now: NOW + 60 * 60 * 1000 }),
+ eventCache,
+ threadCache
+ )
+ expect(decayed.liveAgentByPaneKey[PANE_B]).toBeUndefined()
+ // PANE_A had no live snapshot; its thread survives untouched.
+ expect(threadByPane(decayed.threads, PANE_A)).toBe(threadByPane(first.threads, PANE_A))
+ })
+
+ it('cached builds always equal a cold uncached build (no drift)', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const scenarios: BuildArgs[] = [
+ makeArgs(),
+ makeArgs({ acknowledgedAgentsByPaneKey: { [PANE_A]: NOW } }),
+ makeArgs({ activityClearedAtByPaneKey: { [PANE_A]: NOW } }),
+ makeArgs({
+ runtimeAgentOrchestrationByPaneKey: {
+ [PANE_B]: { taskId: 't1', dispatchId: 'd1', parentPaneKey: PANE_A }
+ }
+ }),
+ makeArgs({ now: NOW + 60 * 60 * 1000 })
+ ]
+ for (const scenario of scenarios) {
+ const cached = buildBoth(scenario, eventCache, threadCache)
+ const cold = buildActivityEvents(scenario)
+ const coldThreads = buildAgentPaneThreads({
+ events: cold.events,
+ liveAgentByPaneKey: cold.liveAgentByPaneKey
+ })
+ expect(cached.events).toEqual(cold.events)
+ expect(cached.liveAgentByPaneKey).toEqual(cold.liveAgentByPaneKey)
+ expect(cached.threads).toEqual(coldThreads)
+ }
+ })
+
+ it('keeps first-source-wins dedupe when a pane is both live and retained, and evicts gone panes', () => {
+ const eventCache = createActivityEventBuildCache()
+ const threadCache = createAgentPaneThreadReuseCache()
+ const retained: RetainedAgentEntry = {
+ entry: entry(PANE_A, { prompt: 'retained copy' }),
+ worktreeId: makeWorktree().id,
+ tab: makeTab(),
+ agentType: 'claude',
+ startedAt: 50_000
+ }
+ const args = makeArgs({ retainedAgentsByPaneKey: { [PANE_A]: retained } })
+ const cachedResult = buildBoth(args, eventCache, threadCache)
+ const cold = buildActivityEvents(args)
+ expect(cachedResult.events).toEqual(cold.events)
+ expect(eventCache.panes.has(`retained:${PANE_A}`)).toBe(true)
+
+ // Retained entry dismissed: its cache row must not linger.
+ buildBoth(makeArgs(), eventCache, threadCache)
+ expect(eventCache.panes.has(`retained:${PANE_A}`)).toBe(false)
+ expect(eventCache.panes.has(`live:${PANE_A}`)).toBe(true)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-event-builder.ts b/src/renderer/src/components/activity/activity-event-builder.ts
index 11e66f65bb2..5e1e3a112ae 100644
--- a/src/renderer/src/components/activity/activity-event-builder.ts
+++ b/src/renderer/src/components/activity/activity-event-builder.ts
@@ -1,33 +1,41 @@
import { isExplicitAgentStatusFresh } from '@/lib/agent-status'
-import { migrationUnsupportedToAgentStatusEntry } from '@/lib/migration-unsupported-agent-entry'
import type { RetainedAgentEntry } from '@/store/slices/agent-status'
import {
AGENT_STATUS_STALE_AFTER_MS,
- type AgentStateHistoryEntry,
type AgentStatusEntry,
+ type AgentStatusOrchestrationContext,
type AgentStatusState,
- type AgentType,
type MigrationUnsupportedPtyEntry
} from '../../../../shared/agent-status-types'
-import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
import type { Repo } from '../../../../shared/repo-types'
import { parsePaneKey } from '../../../../shared/stable-pane-id'
+import type { Tab } from '../../../../shared/tab-types'
import type { TerminalTab } from '../../../../shared/terminal-tab-types'
import type { Worktree } from '../../../../shared/worktree/types'
import type {
ActivityEvent,
- ActivityEventState,
ActivityHookLiveAgentState,
ActivityLiveAgentSnapshot,
ActivityLiveAgentState
} from './activity-thread-types'
import { capActivityEvents } from './activity-event-cap'
+import { newestActivityHistoryEntries } from './activity-pane-events'
+import {
+ createActivityEventBuildCache,
+ resolvePaneBuild,
+ type ActivityEventBuildCache
+} from './activity-event-build-cache'
+import { appendUnsupportedAndRetainedEvents } from './activity-event-builder-sources'
+import {
+ attributedActivityTabContext,
+ buildActivityTabContext,
+ buildActivityTabHostIndex,
+ resolveActivityEventOwner,
+ type ActivityEventOwner
+} from './activity-event-builder-context'
-const STANDALONE_ACTIVITY_WORKTREE_REPO_ID = '__activity_standalone__'
-
-function isActivityEventState(state: AgentStatusState): state is ActivityEventState {
- return state === 'done' || state === 'blocked' || state === 'waiting'
-}
+export { createActivityEventBuildCache, type ActivityEventBuildCache, newestActivityHistoryEntries }
function isActivityHookLiveAgentState(
state: AgentStatusState
@@ -50,142 +58,47 @@ function freshActivityLiveAgentState(
: entry.state
}
-function standaloneActivityWorktree(worktreeId: string): Worktree {
- const displayName =
- worktreeId === FLOATING_TERMINAL_WORKTREE_ID ? 'Floating terminal' : 'Standalone terminal'
- return {
- id: worktreeId,
- repoId: STANDALONE_ACTIVITY_WORKTREE_REPO_ID,
- path: '',
- head: '',
- branch: displayName,
- isBare: false,
- isMainWorktree: false,
- displayName,
- comment: '',
- linkedIssue: null,
- linkedPR: null,
- linkedLinearIssue: null,
- isArchived: false,
- isUnread: false,
- isPinned: false,
- sortOrder: 0,
- lastActivityAt: 0
- }
-}
-
-function historyEntrySnapshot(
- entry: AgentStatusEntry,
- history: AgentStateHistoryEntry
-): AgentStatusEntry {
- return {
- ...entry,
- state: history.state,
- prompt: history.prompt,
- updatedAt: history.startedAt,
- stateStartedAt: history.startedAt,
- stateHistory: [],
- toolName: undefined,
- toolInput: undefined,
- lastAssistantMessage: undefined,
- interrupted: history.interrupted
- }
-}
-
-function appendActivityEvent(args: {
- events: ActivityEvent[]
- seenEventIds: Set
- state: ActivityEventState
- timestamp: number
- worktree: Worktree
- repo: Repo | null
- entry: AgentStatusEntry
- tab: TerminalTab
- agentType: AgentType
- agentAlive: boolean
- acknowledgedAt: number
- migrationUnsupportedPtyId?: string
-}): void {
- const id = `agent:${args.entry.paneKey}:${args.state}:${args.timestamp}`
- if (args.seenEventIds.has(id)) {
- return
- }
- args.seenEventIds.add(id)
- args.events.push({
- id,
- state: args.state,
- timestamp: args.timestamp,
- worktree: args.worktree,
- repo: args.repo,
- entry: args.entry,
- tab: args.tab,
- agentType: args.agentType,
- agentAlive: args.agentAlive,
- migrationUnsupportedPtyId: args.migrationUnsupportedPtyId,
- unread: args.acknowledgedAt < args.timestamp
- })
-}
-
-function appendActivityEventsForEntry(args: {
- events: ActivityEvent[]
- seenEventIds: Set
- entry: AgentStatusEntry
- worktree: Worktree
- repo: Repo | null
- tab: TerminalTab
- agentType: AgentType
- agentAlive: boolean
- acknowledgedAt: number
- migrationUnsupportedPtyId?: string
-}): void {
- // Why: Activity is append-only; when a pane continues (done→working), stateHistory is the only record of the previous done/blocking event.
- for (const history of args.entry.stateHistory) {
- if (!isActivityEventState(history.state)) {
- continue
- }
- appendActivityEvent({
- ...args,
- state: history.state,
- timestamp: history.startedAt,
- entry: historyEntrySnapshot(args.entry, history)
- })
- }
-
- // Why: SessionStart creates an idle row, not an "Agent finished" activity event (STA-3386).
- if (!isActivityEventState(args.entry.state) || args.entry.sessionBoundary === true) {
- return
- }
- appendActivityEvent({
- ...args,
- state: args.entry.state,
- timestamp: args.entry.stateStartedAt
- })
-}
-
-type BuildActivityEventsArgs = {
+export type BuildActivityEventsArgs = {
agentStatusByPaneKey: Record
+ runtimeAgentOrchestrationByPaneKey?: Record
migrationUnsupportedByPtyId?: Record
retainedAgentsByPaneKey: Record
tabsByWorktree: Record
+ unifiedTabsByWorktree?: Record
worktreeMap: Map
repoMap: Map
+ repos?: readonly Repo[]
+ resolveWorktree?: (worktreeId: string, executionHostId?: ExecutionHostId) => Worktree | undefined
acknowledgedAgentsByPaneKey: Record
+ /** Per-pane "Clear completed" cutoffs; events stamped at or before the cutoff are hidden. */
+ activityClearedAtByPaneKey?: Record
now: number
}
-export function buildActivityEvents(args: BuildActivityEventsArgs): {
+export function buildActivityEvents(
+ args: BuildActivityEventsArgs,
+ cache?: ActivityEventBuildCache
+): {
events: ActivityEvent[]
liveAgentByPaneKey: Record
} {
const events: ActivityEvent[] = []
const seenEventIds = new Set()
- const tabContext = new Map()
+ const tabContext = buildActivityTabContext(args.tabsByWorktree, args.unifiedTabsByWorktree)
+ const tabHostIndex = buildActivityTabHostIndex(args.unifiedTabsByWorktree)
+ const ownerCache = new Map()
const liveAgentByPaneKey: Record = {}
+ const seenCacheKeys = cache ? new Set() : null
- for (const [worktreeId, tabs] of Object.entries(args.tabsByWorktree)) {
- const worktree = args.worktreeMap.get(worktreeId) ?? standaloneActivityWorktree(worktreeId)
- for (const tab of tabs) {
- tabContext.set(tab.id, { worktree, tab })
+ const pushPaneEvents = (paneEvents: ActivityEvent[]): void => {
+ // Why: a paneKey can appear in more than one source (live + retained overlap);
+ // event ids stay globally unique so the first source wins, as before.
+ for (const event of paneEvents) {
+ if (seenEventIds.has(event.id)) {
+ continue
+ }
+ seenEventIds.add(event.id)
+ events.push(event)
}
}
@@ -194,101 +107,64 @@ export function buildActivityEvents(args: BuildActivityEventsArgs): {
if (!parsed) {
continue
}
- const context = tabContext.get(parsed.tabId)
+ const context = tabContext.get(parsed.tabId) ?? attributedActivityTabContext(entry)
if (!context) {
continue
}
- const ackAt = args.acknowledgedAgentsByPaneKey[paneKey] ?? 0
+ const owner = resolveActivityEventOwner(
+ args,
+ context,
+ entry,
+ context.tab.ptyId,
+ tabHostIndex,
+ ownerCache
+ )
+ const orchestration = args.runtimeAgentOrchestrationByPaneKey?.[paneKey]
// Why: live status is separate from history; a fresh working turn updates the thread without counting as an unread done/blocked/waiting event.
+ // The freshness check runs on the raw entry (orchestration merges never change state/timing fields).
const liveState = freshActivityLiveAgentState(entry, args.now)
- if (liveState) {
- liveAgentByPaneKey[paneKey] = {
- state: liveState,
- timestamp: entry.stateStartedAt,
- worktree: context.worktree,
- repo: args.repoMap.get(context.worktree.repoId) ?? null,
+ const { events: paneEvents, live } = resolvePaneBuild(
+ {
+ cacheKey: `live:${paneKey}`,
+ source: entry,
entry,
+ orchestration,
+ worktree: owner.worktree,
+ repo: owner.repo,
tab: context.tab,
- agentType: entry.agentType ?? 'unknown'
+ agentType: entry.agentType ?? 'unknown',
+ agentAlive: true,
+ acknowledgedAt: args.acknowledgedAgentsByPaneKey[paneKey] ?? 0,
+ clearedAt: args.activityClearedAtByPaneKey?.[paneKey] ?? 0,
+ liveState
+ },
+ cache,
+ seenCacheKeys
+ )
+ if (live) {
+ liveAgentByPaneKey[paneKey] = live
+ }
+ pushPaneEvents(paneEvents)
+ }
+
+ appendUnsupportedAndRetainedEvents({
+ args,
+ cache,
+ seenCacheKeys,
+ liveAgentByPaneKey,
+ tabContext,
+ resolveOwner: (context, entry, terminalPtyId) =>
+ resolveActivityEventOwner(args, context, entry, terminalPtyId, tabHostIndex, ownerCache),
+ pushPaneEvents
+ })
+
+ // Why: evict panes gone from every source so the cache can't outgrow the live state maps.
+ if (cache && seenCacheKeys) {
+ for (const cacheKey of cache.panes.keys()) {
+ if (!seenCacheKeys.has(cacheKey)) {
+ cache.panes.delete(cacheKey)
}
}
- appendActivityEventsForEntry({
- events,
- seenEventIds,
- worktree: context.worktree,
- repo: args.repoMap.get(context.worktree.repoId) ?? null,
- entry,
- tab: context.tab,
- agentType: entry.agentType ?? 'unknown',
- agentAlive: true,
- acknowledgedAt: ackAt
- })
}
-
- appendUnsupportedAndRetainedEvents(args, events, seenEventIds, liveAgentByPaneKey, tabContext)
return { events: capActivityEvents(events), liveAgentByPaneKey }
}
-
-function appendUnsupportedAndRetainedEvents(
- args: BuildActivityEventsArgs,
- events: ActivityEvent[],
- seenEventIds: Set,
- liveAgentByPaneKey: Record,
- tabContext: Map
-): void {
- for (const unsupported of Object.values(args.migrationUnsupportedByPtyId ?? {})) {
- const entry = migrationUnsupportedToAgentStatusEntry(unsupported)
- const parsed = entry ? parsePaneKey(entry.paneKey) : null
- const context = parsed ? tabContext.get(parsed.tabId) : null
- if (!entry || !context) {
- continue
- }
- const ackAt = args.acknowledgedAgentsByPaneKey[entry.paneKey] ?? 0
- liveAgentByPaneKey[entry.paneKey] = {
- state: 'blocked',
- timestamp: entry.stateStartedAt,
- worktree: context.worktree,
- repo: args.repoMap.get(context.worktree.repoId) ?? null,
- entry,
- tab: context.tab,
- agentType: entry.agentType ?? 'unknown'
- }
- appendActivityEventsForEntry({
- events,
- seenEventIds,
- worktree: context.worktree,
- repo: args.repoMap.get(context.worktree.repoId) ?? null,
- entry,
- tab: context.tab,
- agentType: entry.agentType ?? 'unknown',
- agentAlive: false,
- acknowledgedAt: ackAt,
- migrationUnsupportedPtyId: unsupported.ptyId
- })
- }
-
- for (const [paneKey, retained] of Object.entries(args.retainedAgentsByPaneKey)) {
- if (!parsePaneKey(paneKey)) {
- continue
- }
- const worktree =
- args.worktreeMap.get(retained.worktreeId) ??
- (args.tabsByWorktree[retained.worktreeId]
- ? standaloneActivityWorktree(retained.worktreeId)
- : null)
- if (!worktree) {
- continue
- }
- appendActivityEventsForEntry({
- events,
- seenEventIds,
- worktree,
- repo: args.repoMap.get(worktree.repoId) ?? null,
- entry: retained.entry,
- tab: retained.tab,
- agentType: retained.agentType,
- agentAlive: false,
- acknowledgedAt: args.acknowledgedAgentsByPaneKey[paneKey] ?? 0
- })
- }
-}
diff --git a/src/renderer/src/components/activity/activity-event-cap.ts b/src/renderer/src/components/activity/activity-event-cap.ts
index c6b80d53823..54d84c3039c 100644
--- a/src/renderer/src/components/activity/activity-event-cap.ts
+++ b/src/renderer/src/components/activity/activity-event-cap.ts
@@ -1,7 +1,8 @@
import type { ActivityEvent } from './activity-thread-types'
// Why: per-pane cap guarantees each agent appears in the left list even when one pane has a long history.
-const EVENTS_PER_PANE_CAP = 5
+// Exported so the event builder can skip building history entries the cap would drop anyway.
+export const EVENTS_PER_PANE_CAP = 5
export function capActivityEvents(events: ActivityEvent[]): ActivityEvent[] {
const sorted = events.sort((a, b) => b.timestamp - a.timestamp)
diff --git a/src/renderer/src/components/activity/activity-pane-events.ts b/src/renderer/src/components/activity/activity-pane-events.ts
new file mode 100644
index 00000000000..d3da82e5486
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-pane-events.ts
@@ -0,0 +1,108 @@
+import type {
+ AgentStateHistoryEntry,
+ AgentStatusEntry
+} from '../../../../shared/agent-status-types'
+import type { Repo } from '../../../../shared/repo-types'
+import type { TerminalTab } from '../../../../shared/terminal-tab-types'
+import type { Worktree } from '../../../../shared/worktree/types'
+import type { ActivityEvent, ActivityEventState } from './activity-thread-types'
+import { EVENTS_PER_PANE_CAP } from './activity-event-cap'
+
+export function isActivityEventState(
+ state: AgentStatusEntry['state']
+): state is ActivityEventState {
+ return state === 'done' || state === 'blocked' || state === 'waiting'
+}
+
+function historyEntrySnapshot(
+ entry: AgentStatusEntry,
+ history: AgentStateHistoryEntry
+): AgentStatusEntry {
+ return {
+ ...entry,
+ state: history.state,
+ prompt: history.prompt,
+ updatedAt: history.startedAt,
+ stateStartedAt: history.startedAt,
+ stateHistory: [],
+ toolName: undefined,
+ toolInput: undefined,
+ lastAssistantMessage: undefined,
+ interrupted: history.interrupted
+ }
+}
+
+/** Newest activity-eligible history entries, at most `cap`, oldest-first. */
+export function newestActivityHistoryEntries(
+ history: readonly AgentStateHistoryEntry[],
+ cap: number
+): AgentStateHistoryEntry[] {
+ const newest: AgentStateHistoryEntry[] = []
+ for (let i = history.length - 1; i >= 0 && newest.length < cap; i -= 1) {
+ if (isActivityEventState(history[i].state)) {
+ newest.push(history[i])
+ }
+ }
+ return newest.toReversed()
+}
+
+type PaneEventInputs = {
+ entry: AgentStatusEntry
+ worktree: Worktree
+ repo: Repo | null
+ tab: TerminalTab
+ agentType: AgentStatusEntry['agentType']
+ agentAlive: boolean
+ acknowledgedAt: number
+ clearedAt: number
+ migrationUnsupportedPtyId?: string
+}
+
+/** Build one pane's activity events (bounded by the per-pane cap, cutoff applied). */
+export function buildPaneActivityEvents(args: PaneEventInputs): ActivityEvent[] {
+ const events: ActivityEvent[] = []
+ const seenIds = new Set()
+ const append = (state: ActivityEventState, timestamp: number, entry: AgentStatusEntry): void => {
+ const id = `agent:${entry.paneKey}:${state}:${timestamp}`
+ if (seenIds.has(id)) {
+ return
+ }
+ seenIds.add(id)
+ events.push({
+ id,
+ state,
+ timestamp,
+ worktree: args.worktree,
+ repo: args.repo,
+ entry,
+ tab: args.tab,
+ agentType: args.agentType ?? 'unknown',
+ agentAlive: args.agentAlive,
+ migrationUnsupportedPtyId: args.migrationUnsupportedPtyId,
+ unread: args.acknowledgedAt < timestamp
+ })
+ }
+
+ for (const history of newestActivityHistoryEntries(
+ args.entry.stateHistory,
+ EVENTS_PER_PANE_CAP
+ )) {
+ if (history.startedAt <= args.clearedAt) {
+ continue
+ }
+ append(
+ history.state as ActivityEventState,
+ history.startedAt,
+ historyEntrySnapshot(args.entry, history)
+ )
+ }
+
+ if (!isActivityEventState(args.entry.state) || args.entry.sessionBoundary === true) {
+ return events
+ }
+ if (args.entry.stateStartedAt <= args.clearedAt) {
+ return events
+ }
+ append(args.entry.state, args.entry.stateStartedAt, args.entry)
+ return events
+}
diff --git a/src/renderer/src/components/activity/activity-scope-filter-controls.tsx b/src/renderer/src/components/activity/activity-scope-filter-controls.tsx
new file mode 100644
index 00000000000..6256595ba6b
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-scope-filter-controls.tsx
@@ -0,0 +1,170 @@
+import React, { useMemo } from 'react'
+import { X } from 'lucide-react'
+import { useAppStore } from '@/store'
+import { DropdownMenuLabel, DropdownMenuSeparator } from '@/components/ui/dropdown-menu'
+import SidebarRepositoryFilterSection from '@/components/sidebar/SidebarRepositoryFilterSection'
+import { SidebarHostScopeMenuSection } from '@/components/sidebar/SidebarHostScopeMenuSection'
+import {
+ getSidebarHostVisibilityLabel,
+ shouldShowHostScopeControls
+} from '@/components/sidebar/sidebar-host-options'
+import { useSidebarHostScopeOptions } from '@/components/sidebar/use-sidebar-host-scope-options'
+import type { SidebarHostOption } from '@/components/sidebar/sidebar-host-options'
+import { getExecutionHostLabel, type ExecutionHostId } from '../../../../shared/execution-host'
+import { translate } from '@/i18n/i18n'
+
+/**
+ * Host/project scope controls for the Agents activity surfaces. State is the
+ * persisted agents-view scope (agentsVisibleHostIds / agentsFilterRepoIds),
+ * deliberately separate from the workspace-nav filters.
+ */
+export function ActivityScopeFilterMenuSections(): React.JSX.Element | null {
+ const repos = useAppStore((s) => s.repos)
+ const agentsVisibleHostIds = useAppStore((s) => s.agentsVisibleHostIds)
+ const setAgentsVisibleHostIds = useAppStore((s) => s.setAgentsVisibleHostIds)
+ const agentsFilterRepoIds = useAppStore((s) => s.agentsFilterRepoIds)
+ const setAgentsFilterRepoIds = useAppStore((s) => s.setAgentsFilterRepoIds)
+ const { hostOptions } = useSidebarHostScopeOptions()
+ const showHostScopeControls = shouldShowHostScopeControls(hostOptions)
+
+ if (!showHostScopeControls && repos.length <= 1) {
+ return null
+ }
+ return (
+ <>
+
+ {translate('auto.components.sidebar.SidebarWorkspaceOptionsMenu.showSection', 'Show')}
+
+ {showHostScopeControls ? (
+ setAgentsVisibleHostIds(null)}
+ visibleWorkspaceHostIds={agentsVisibleHostIds}
+ setVisibleWorkspaceHostIds={setAgentsVisibleHostIds}
+ />
+ ) : null}
+ = {}): AgentPaneThread {
+ const worktree = makeWorktree()
+ return {
+ paneKey: PANE_KEY,
+ paneTitle: 'Test Agent',
+ agentType: 'claude',
+ worktree,
+ repo: makeRepo(),
+ tab: makeTabWithIds('tab-1', worktree.id),
+ events: [],
+ latestEvent: null,
+ latestTimestamp: 1000,
+ currentAgentState: 'working',
+ currentAgentEntry: null,
+ unread: false,
+ responsePreview: '',
+ ...overrides
+ }
+}
+
+function makeScope(overrides: Partial = {}): ActivityScopeFilter {
+ return {
+ visibleHostIds: null,
+ filterRepoIds: [],
+ defaultHostId: LOCAL_EXECUTION_HOST_ID,
+ ...overrides
+ }
+}
+
+describe('threadMatchesActivityScope', () => {
+ it('matches everything when no scope is active', () => {
+ expect(threadMatchesActivityScope(makeThread(), makeScope())).toBe(true)
+ expect(threadMatchesActivityScope(makeThread({ repo: null }), makeScope())).toBe(true)
+ })
+
+ it('filters by execution host, falling back to the default host for local worktrees', () => {
+ const local = makeThread()
+ const remote = makeThread({
+ worktree: { ...makeWorktree(), hostId: SSH_HOST }
+ })
+ const localOnly = makeScope({ visibleHostIds: [LOCAL_EXECUTION_HOST_ID] })
+ expect(threadMatchesActivityScope(local, localOnly)).toBe(true)
+ expect(threadMatchesActivityScope(remote, localOnly)).toBe(false)
+ const remoteOnly = makeScope({ visibleHostIds: [SSH_HOST] })
+ expect(threadMatchesActivityScope(local, remoteOnly)).toBe(false)
+ expect(threadMatchesActivityScope(remote, remoteOnly)).toBe(true)
+ })
+
+ it('filters by project and hides repo-less threads under a project scope', () => {
+ const scope = makeScope({ filterRepoIds: ['repo-1'] })
+ expect(threadMatchesActivityScope(makeThread(), scope)).toBe(true)
+ expect(
+ threadMatchesActivityScope(makeThread({ repo: { ...makeRepo(), id: 'repo-2' } }), scope)
+ ).toBe(false)
+ expect(threadMatchesActivityScope(makeThread({ repo: null }), scope)).toBe(false)
+ })
+})
+
+describe('filterThreadsByActivityScope', () => {
+ it('returns the input array by identity when the scope is inactive', () => {
+ const threads = [makeThread(), makeThread({ paneKey: 'pane-2', repo: null })]
+ const result = filterThreadsByActivityScope({
+ threads,
+ scope: makeScope(),
+ exemptPaneKey: null
+ })
+ expect(result.threads).toBe(threads)
+ expect(result.matchingThreads).toBe(threads)
+ expect(result.hiddenCount).toBe(0)
+ })
+
+ it('returns the input array by identity when an active scope hides nothing', () => {
+ const threads = [makeThread()]
+ const result = filterThreadsByActivityScope({
+ threads,
+ scope: makeScope({ visibleHostIds: [LOCAL_EXECUTION_HOST_ID] }),
+ exemptPaneKey: null
+ })
+ expect(result.threads).toBe(threads)
+ expect(result.matchingThreads).toBe(threads)
+ expect(result.hiddenCount).toBe(0)
+ })
+
+ it('hides scoped-out threads but keeps the exempt pane, counting only real hides', () => {
+ const local = makeThread()
+ const remote = makeThread({
+ paneKey: 'pane-remote',
+ worktree: { ...makeWorktree(), hostId: SSH_HOST }
+ })
+ const exemptRemote = makeThread({
+ paneKey: 'pane-exempt',
+ worktree: { ...makeWorktree(), hostId: SSH_HOST }
+ })
+ const result = filterThreadsByActivityScope({
+ threads: [local, remote, exemptRemote],
+ scope: makeScope({ visibleHostIds: [LOCAL_EXECUTION_HOST_ID] }),
+ exemptPaneKey: 'pane-exempt'
+ })
+ expect(result.threads).toEqual([local, exemptRemote])
+ expect(result.matchingThreads).toEqual([local])
+ expect(result.hiddenCount).toBe(1)
+ })
+})
+
+describe('resolveActivityScopeRepoIds', () => {
+ it('drops stale repo ids so they cannot count as an active filter', () => {
+ const repoMap = new Map([['repo-1', makeRepo()]])
+ expect(resolveActivityScopeRepoIds(['repo-1', 'gone-repo'], repoMap)).toEqual(['repo-1'])
+ expect(resolveActivityScopeRepoIds(['gone-repo'], repoMap)).toEqual([])
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-scope-filter.ts b/src/renderer/src/components/activity/activity-scope-filter.ts
new file mode 100644
index 00000000000..36dfafa8cf6
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-scope-filter.ts
@@ -0,0 +1,80 @@
+import type { ExecutionHostId } from '../../../../shared/execution-host'
+import { getWorktreeExecutionHostId } from '../../../../shared/execution-host'
+import type { Repo } from '../../../../shared/repo-types'
+import type { AgentPaneThread } from './activity-thread-types'
+
+/** Host/project scope for the Agents activity surfaces. Persisted and separate
+ * from the workspace-nav filters; hosts `null` = all, repoIds empty = all. */
+export type ActivityScopeFilter = {
+ visibleHostIds: readonly ExecutionHostId[] | null
+ filterRepoIds: readonly string[]
+ defaultHostId: ExecutionHostId
+}
+
+/** Repo ids that still exist; stale persisted ids must not count as an active filter. */
+export function resolveActivityScopeRepoIds(
+ filterRepoIds: readonly string[],
+ repoMap: ReadonlyMap
+): string[] {
+ return filterRepoIds.filter((repoId) => repoMap.has(repoId))
+}
+
+/**
+ * Apply the scope to a thread list. Returns the input array by identity when
+ * the scope is inactive or hides nothing, so downstream memos (visible threads,
+ * grouping) see an unchanged dep instead of re-running on every rebuild.
+ */
+export function filterThreadsByActivityScope(args: {
+ threads: AgentPaneThread[]
+ scope: ActivityScopeFilter
+ /** Kept visible even when scoped out, so changing scope can't vanish the open row. */
+ exemptPaneKey: string | null
+}): {
+ threads: AgentPaneThread[]
+ /** Strict matches for bulk actions; excludes a selected row kept visible only by the exemption. */
+ matchingThreads: AgentPaneThread[]
+ hiddenCount: number
+} {
+ const { threads, scope, exemptPaneKey } = args
+ if (!scope.visibleHostIds && scope.filterRepoIds.length === 0) {
+ return { threads, matchingThreads: threads, hiddenCount: 0 }
+ }
+ const matchingThreads: AgentPaneThread[] = []
+ const visibleThreads: AgentPaneThread[] = []
+ for (const thread of threads) {
+ if (threadMatchesActivityScope(thread, scope)) {
+ matchingThreads.push(thread)
+ visibleThreads.push(thread)
+ } else if (thread.paneKey === exemptPaneKey) {
+ visibleThreads.push(thread)
+ }
+ }
+ return {
+ threads: visibleThreads.length === threads.length ? threads : visibleThreads,
+ matchingThreads: matchingThreads.length === threads.length ? threads : matchingThreads,
+ hiddenCount: threads.length - visibleThreads.length
+ }
+}
+
+export function threadMatchesActivityScope(
+ thread: AgentPaneThread,
+ scope: ActivityScopeFilter
+): boolean {
+ if (scope.visibleHostIds) {
+ const hostId = getWorktreeExecutionHostId(
+ thread.worktree,
+ thread.repo ?? undefined,
+ scope.defaultHostId
+ )
+ if (!scope.visibleHostIds.includes(hostId)) {
+ return false
+ }
+ }
+ // Why: repo-less terminal buckets have no project, so a project scope hides them.
+ if (scope.filterRepoIds.length > 0) {
+ if (!thread.repo || !scope.filterRepoIds.includes(thread.repo.id)) {
+ return false
+ }
+ }
+ return true
+}
diff --git a/src/renderer/src/components/activity/activity-standalone-worktree.ts b/src/renderer/src/components/activity/activity-standalone-worktree.ts
new file mode 100644
index 00000000000..9844fbb9896
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-standalone-worktree.ts
@@ -0,0 +1,67 @@
+import { i18n, translate } from '@/i18n/i18n'
+import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../../shared/constants'
+import type { Worktree } from '../../../../shared/worktree/types'
+import type { ExecutionHostId } from '../../../../shared/execution-host'
+
+const STANDALONE_ACTIVITY_WORKTREE_REPO_ID = '__activity_standalone__'
+const STANDALONE_ACTIVITY_WORKTREES_CAP = 200
+const standaloneActivityWorktrees = new Map()
+// The cached rows carry a localized displayName, so they cannot outlive a language switch.
+let cachedDisplayNameLocale: string | undefined
+
+function buildStandaloneActivityWorktree(
+ worktreeId: string,
+ executionHostId?: ExecutionHostId
+): Worktree {
+ const displayName =
+ worktreeId === FLOATING_TERMINAL_WORKTREE_ID
+ ? translate(
+ 'auto.components.activity.standaloneWorktree.floatingTerminal',
+ 'Floating terminal'
+ )
+ : translate(
+ 'auto.components.activity.standaloneWorktree.standaloneTerminal',
+ 'Standalone terminal'
+ )
+ return {
+ id: worktreeId,
+ ...(executionHostId ? { hostId: executionHostId } : {}),
+ repoId: STANDALONE_ACTIVITY_WORKTREE_REPO_ID,
+ path: '',
+ head: '',
+ branch: displayName,
+ isBare: false,
+ isMainWorktree: false,
+ displayName,
+ comment: '',
+ linkedIssue: null,
+ linkedPR: null,
+ linkedLinearIssue: null,
+ isArchived: false,
+ isUnread: false,
+ isPinned: false,
+ sortOrder: 0,
+ lastActivityAt: 0
+ }
+}
+
+/** Return a stable synthetic worktree for terminal-only activity. */
+export function standaloneActivityWorktree(
+ worktreeId: string,
+ executionHostId?: ExecutionHostId
+): Worktree {
+ if (cachedDisplayNameLocale !== i18n.language) {
+ cachedDisplayNameLocale = i18n.language
+ standaloneActivityWorktrees.clear()
+ }
+ const cacheKey = `${worktreeId}\0${executionHostId ?? ''}`
+ let worktree = standaloneActivityWorktrees.get(cacheKey)
+ if (!worktree) {
+ if (standaloneActivityWorktrees.size >= STANDALONE_ACTIVITY_WORKTREES_CAP) {
+ standaloneActivityWorktrees.clear()
+ }
+ worktree = buildStandaloneActivityWorktree(worktreeId, executionHostId)
+ standaloneActivityWorktrees.set(cacheKey, worktree)
+ }
+ return worktree
+}
diff --git a/src/renderer/src/components/activity/activity-tab-projection.ts b/src/renderer/src/components/activity/activity-tab-projection.ts
new file mode 100644
index 00000000000..028d474d519
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-tab-projection.ts
@@ -0,0 +1,66 @@
+import type { Tab } from '../../../../shared/tab-types'
+
+/**
+ * Stable view of the unified tab map for the activity pipeline.
+ *
+ * Why: the store rewrites the focused tab object (lastFocusedAt) on every focus, which would
+ * rebuild every activity thread even though nothing the pipeline reads changed. Keep only the
+ * tab kinds the pipeline consults and reuse prior tab objects when their relevant fields match,
+ * so downstream identity-keyed caches keep hitting.
+ */
+export type ActivityTabProjection = Record
+
+function isActivityRelevantTab(tab: Tab): boolean {
+ return tab.contentType === 'terminal' || tab.contentType === 'agent-session'
+}
+
+function activityTabFieldsEqual(a: Tab, b: Tab): boolean {
+ return (
+ a.id === b.id &&
+ a.entityId === b.entityId &&
+ a.worktreeId === b.worktreeId &&
+ a.executionHostId === b.executionHostId &&
+ a.contentType === b.contentType &&
+ a.label === b.label &&
+ a.generatedLabel === b.generatedLabel &&
+ a.customLabel === b.customLabel &&
+ a.color === b.color &&
+ a.isPinned === b.isPinned &&
+ a.sortOrder === b.sortOrder &&
+ a.createdAt === b.createdAt
+ )
+}
+
+export function projectActivityTabs(
+ unifiedTabsByWorktree: Record | undefined,
+ previous: ActivityTabProjection | null
+): ActivityTabProjection {
+ const next: ActivityTabProjection = {}
+ let changed = previous === null
+ for (const [worktreeId, tabs] of Object.entries(unifiedTabsByWorktree ?? {})) {
+ const relevant = tabs.filter(isActivityRelevantTab)
+ if (relevant.length === 0) {
+ continue
+ }
+ const prior = previous?.[worktreeId]
+ let reusable = prior !== undefined && prior.length === relevant.length
+ const projected = relevant.map((tab, index) => {
+ const priorTab = prior?.[index]
+ if (priorTab && activityTabFieldsEqual(priorTab, tab)) {
+ return priorTab
+ }
+ reusable = false
+ return tab
+ })
+ if (reusable && prior) {
+ next[worktreeId] = prior
+ } else {
+ next[worktreeId] = projected
+ changed = true
+ }
+ }
+ if (!changed && previous && Object.keys(previous).length === Object.keys(next).length) {
+ return previous
+ }
+ return next
+}
diff --git a/src/renderer/src/components/activity/activity-thread-actions.test.ts b/src/renderer/src/components/activity/activity-thread-actions.test.ts
new file mode 100644
index 00000000000..ce2de01fe02
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-actions.test.ts
@@ -0,0 +1,162 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { makeRepo, makeTab, makeWorktree } from './ActivityPrototypePage-test-fixtures'
+import type { AgentPaneThread } from './activity-thread-types'
+
+const mocks = vi.hoisted(() => ({
+ getState: vi.fn(),
+ activateTabAndFocusPane: vi.fn(),
+ activateStructuredAgentSessionTab: vi.fn(),
+ activateAndRevealWorkspace: vi.fn()
+}))
+
+vi.mock('@/store', () => ({ useAppStore: { getState: mocks.getState } }))
+vi.mock('@/lib/activate-tab-and-focus-pane', () => ({
+ activateTabAndFocusPane: mocks.activateTabAndFocusPane
+}))
+vi.mock('@/lib/structured-agent-session-tab-activation', () => ({
+ activateStructuredAgentSessionTab: mocks.activateStructuredAgentSessionTab
+}))
+vi.mock('@/lib/worktree-activation', () => ({
+ activateAndRevealWorkspace: mocks.activateAndRevealWorkspace
+}))
+
+import { createActivityThreadActions, hasActivityThreadWorkspace } from './activity-thread-actions'
+
+const REMOTE_HOST = 'ssh:devbox' as const
+
+function makeRemoteThread(): AgentPaneThread {
+ const worktree = { ...makeWorktree(), hostId: REMOTE_HOST }
+ return {
+ paneKey: 'tab-1:11111111-1111-4111-8111-111111111111',
+ paneTitle: 'Remote agent',
+ agentType: 'claude',
+ worktree,
+ repo: makeRepo(),
+ tab: makeTab(),
+ events: [],
+ latestEvent: null,
+ latestTimestamp: 1_000,
+ currentAgentState: 'working',
+ currentAgentEntry: null,
+ unread: true,
+ responsePreview: ''
+ }
+}
+
+describe('activity thread host routing', () => {
+ const thread = makeRemoteThread()
+ const getKnownWorktreeById = vi.fn()
+ const setActiveWorktree = vi.fn()
+ const acknowledgeAgents = vi.fn()
+ const setSelectedPaneKey = vi.fn()
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mocks.activateStructuredAgentSessionTab.mockReturnValue(false)
+ getKnownWorktreeById.mockReturnValue(thread.worktree)
+ mocks.getState.mockReturnValue({
+ getKnownWorktreeById,
+ worktreesByRepo: { [thread.worktree.repoId]: [thread.worktree] },
+ detectedWorktreesByRepo: {},
+ folderWorkspaces: [],
+ showSleepingWorkspaces: true,
+ filterRepoIds: [],
+ hideDefaultBranchWorkspace: false,
+ hideAutomationGeneratedWorkspaces: false,
+ hideCliCreatedWorkspaces: false,
+ hideDetachedHeadWorkspaces: false,
+ hideWorkspacesFromOtherDevices: false,
+ alwaysShowDefaultBranchWorkspace: true,
+ visibleWorkspaceHostIds: null,
+ workspaceHostScope: 'all',
+ tabsByWorktree: { [thread.worktree.id]: [thread.tab] },
+ unifiedTabsByWorktree: {},
+ activeRepoId: thread.worktree.repoId,
+ activeWorktreeId: thread.worktree.id,
+ activeWorkspaceExecutionHostId: 'local',
+ setActiveRepo: vi.fn(),
+ setActiveWorktree,
+ setActiveTabType: vi.fn()
+ })
+ })
+
+ it('selects the matching host when the same workspace id is active elsewhere', () => {
+ const actions = createActivityThreadActions({
+ getMarkAllReadThreads: () => [thread],
+ acknowledgeAgents,
+ unacknowledgeAgents: vi.fn(),
+ setSelectedPaneKey
+ })
+
+ actions.selectThread(thread)
+
+ expect(getKnownWorktreeById).toHaveBeenCalledWith(thread.worktree.id, REMOTE_HOST)
+ expect(setActiveWorktree).toHaveBeenCalledWith(thread.worktree.id, REMOTE_HOST)
+ expect(mocks.activateTabAndFocusPane).toHaveBeenCalledWith(
+ thread.tab.id,
+ '11111111-1111-4111-8111-111111111111',
+ { flashFocusedPane: true, scrollToBottomIfOutputSinceLastView: true }
+ )
+ })
+
+ it('activates a structured agent session instead of looking for a terminal pane', () => {
+ mocks.activateStructuredAgentSessionTab.mockReturnValue(true)
+ mocks.getState.mockReturnValue({
+ ...mocks.getState(),
+ tabsByWorktree: { [thread.worktree.id]: [] },
+ unifiedTabsByWorktree: {
+ [thread.worktree.id]: [{ id: thread.tab.id, contentType: 'agent-session' }]
+ }
+ })
+ const actions = createActivityThreadActions({
+ getMarkAllReadThreads: () => [thread],
+ acknowledgeAgents,
+ unacknowledgeAgents: vi.fn(),
+ setSelectedPaneKey
+ })
+
+ actions.selectThread(thread)
+
+ expect(mocks.activateStructuredAgentSessionTab).toHaveBeenCalledWith({
+ worktreeId: thread.worktree.id,
+ tabId: thread.tab.id
+ })
+ expect(mocks.activateTabAndFocusPane).not.toHaveBeenCalled()
+ })
+
+ it('jumps to and probes the matching host-qualified workspace', () => {
+ expect(hasActivityThreadWorkspace(thread)).toBe(true)
+ const actions = createActivityThreadActions({
+ getMarkAllReadThreads: () => [thread],
+ acknowledgeAgents,
+ unacknowledgeAgents: vi.fn(),
+ setSelectedPaneKey
+ })
+
+ actions.jumpToWorkspace(thread)
+
+ expect(acknowledgeAgents).toHaveBeenCalledWith([thread.paneKey])
+ expect(mocks.activateAndRevealWorkspace).toHaveBeenCalledWith(thread.worktree.id, {
+ executionHostId: REMOTE_HOST
+ })
+ })
+
+ it('marks all unread threads in the mark-all set, reading it at call time', () => {
+ const readThread = { ...makeRemoteThread(), paneKey: 'tab-2:read', unread: false }
+ let markAllSet = [readThread]
+ const actions = createActivityThreadActions({
+ getMarkAllReadThreads: () => markAllSet,
+ acknowledgeAgents,
+ unacknowledgeAgents: vi.fn(),
+ setSelectedPaneKey
+ })
+
+ actions.markAllThreadsRead()
+ expect(acknowledgeAgents).not.toHaveBeenCalled()
+
+ // The handler keeps one identity while the set changes underneath it.
+ markAllSet = [thread, readThread]
+ actions.markAllThreadsRead()
+ expect(acknowledgeAgents).toHaveBeenCalledWith([thread.paneKey])
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-thread-actions.ts b/src/renderer/src/components/activity/activity-thread-actions.ts
index f1e1ff6ae5b..b0971da7ea7 100644
--- a/src/renderer/src/components/activity/activity-thread-actions.ts
+++ b/src/renderer/src/components/activity/activity-thread-actions.ts
@@ -1,22 +1,65 @@
import { activateTabAndFocusPane } from '@/lib/activate-tab-and-focus-pane'
-import { activateAndRevealWorktree } from '@/lib/worktree-activation'
+import { activateStructuredAgentSessionTab } from '@/lib/structured-agent-session-tab-activation'
+import { jumpToWorktreeFromSidebar } from '@/lib/worktree-jump-navigation'
import { useAppStore } from '@/store'
-import { getWorktreeMapFromState } from '@/store/selectors'
+import {
+ getSettingsFocusedExecutionHostId,
+ getWorktreeExecutionHostId,
+ type ExecutionHostId
+} from '../../../../shared/execution-host'
import { parsePaneKey } from '../../../../shared/stable-pane-id'
+import { findKnownWorktreeById } from '@/store/slices/worktrees/listing/detected-worktree-meta'
+import type { AppState } from '@/store/types'
import type { AgentPaneThread } from './activity-thread-types'
+// Same focused-host fallback the Agents scope filter uses; defaulting to `local` here would
+// look up a hostless runtime-owned workspace on the wrong host and silently drop the jump.
+function getActivityThreadExecutionHostId(
+ thread: AgentPaneThread,
+ defaultHostId: ExecutionHostId
+): ExecutionHostId {
+ return getWorktreeExecutionHostId(thread.worktree, thread.repo ?? undefined, defaultHostId)
+}
+
+type ActivityThreadWorkspaceCatalog = Pick<
+ AppState,
+ 'worktreesByRepo' | 'detectedWorktreesByRepo' | 'folderWorkspaces'
+> & { defaultHostId: ExecutionHostId }
+
+function readActivityThreadWorkspaceCatalog(): ActivityThreadWorkspaceCatalog {
+ const state = useAppStore.getState()
+ return { ...state, defaultHostId: getSettingsFocusedExecutionHostId(state.settings) }
+}
+
+export function hasActivityThreadWorkspace(
+ thread: AgentPaneThread,
+ catalog: ActivityThreadWorkspaceCatalog = readActivityThreadWorkspaceCatalog()
+): boolean {
+ return Boolean(
+ findKnownWorktreeById(
+ catalog,
+ thread.worktree.id,
+ getActivityThreadExecutionHostId(thread, catalog.defaultHostId)
+ )
+ )
+}
+
export function createActivityThreadActions({
- allThreads,
+ getMarkAllReadThreads,
acknowledgeAgents,
unacknowledgeAgents,
setSelectedPaneKey
}: {
- allThreads: AgentPaneThread[]
+ /** Getter (not a snapshot) so the handlers keep one identity for the row memo
+ * bail-outs while bulk actions still see the current thread set. This is the
+ * badge-coherent set (child-filter only), not the search/scope-narrowed one,
+ * so Mark all read always drives the Agents badge to zero. */
+ getMarkAllReadThreads: () => AgentPaneThread[]
acknowledgeAgents: (paneKeys: string[]) => void
unacknowledgeAgents: (paneKeys: string[]) => void
setSelectedPaneKey: (paneKey: string | null) => void
}): {
- hasUnreadThreads: boolean
+ markThreadRead: (thread: AgentPaneThread) => void
markThreadUnread: (thread: AgentPaneThread) => void
selectThread: (thread: AgentPaneThread) => void
jumpToWorkspace: (thread: AgentPaneThread) => void
@@ -30,51 +73,67 @@ export function createActivityThreadActions({
unacknowledgeAgents([thread.paneKey])
}
- const activateThreadTerminal = (thread: AgentPaneThread): void => {
+ const activateThreadTarget = (thread: AgentPaneThread): void => {
const state = useAppStore.getState()
- const worktree = getWorktreeMapFromState(state).get(thread.worktree.id)
+ const executionHostId = getActivityThreadExecutionHostId(
+ thread,
+ getSettingsFocusedExecutionHostId(state.settings)
+ )
+ const worktree = state.getKnownWorktreeById(thread.worktree.id, executionHostId)
if (!worktree) {
return
}
- // Why: retained-agent threads can outlive their tab; without a live tab, reorienting the workspace and focusing a dead tab id would just confuse the user.
const liveTabs = state.tabsByWorktree[worktree.id] ?? []
- const hasLiveTab = liveTabs.some((t) => t.id === thread.tab.id)
- if (!hasLiveTab) {
+ const hasLiveTerminal = liveTabs.some((tab) => tab.id === thread.tab.id)
+ const hasLiveAgentSession = (state.unifiedTabsByWorktree?.[worktree.id] ?? []).some(
+ (tab) => tab.id === thread.tab.id && tab.contentType === 'agent-session'
+ )
+ // Why: retained threads can outlive their target; reorienting the workspace for a
+ // dead terminal or structured session would just confuse the user.
+ if (!hasLiveTerminal && !hasLiveAgentSession) {
return
}
if (state.activeRepoId !== worktree.repoId) {
state.setActiveRepo(worktree.repoId)
}
- if (state.activeWorktreeId !== worktree.id) {
- state.setActiveWorktree(worktree.id)
+ if (
+ state.activeWorktreeId !== worktree.id ||
+ state.activeWorkspaceExecutionHostId !== executionHostId
+ ) {
+ state.setActiveWorktree(worktree.id, executionHostId)
+ }
+ if (activateStructuredAgentSessionTab({ worktreeId: worktree.id, tabId: thread.tab.id })) {
+ return
}
state.setActiveTabType('terminal')
const parsed = parsePaneKey(thread.paneKey)
activateTabAndFocusPane(
thread.tab.id,
parsed && parsed.tabId === thread.tab.id ? parsed.leafId : null,
- { scrollToBottomIfOutputSinceLastView: true }
+ { flashFocusedPane: true, scrollToBottomIfOutputSinceLastView: true }
)
}
const selectThread = (thread: AgentPaneThread): void => {
setSelectedPaneKey(thread.paneKey)
- activateThreadTerminal(thread)
+ activateThreadTarget(thread)
}
const jumpToWorkspace = (thread: AgentPaneThread): void => {
- const state = useAppStore.getState()
- if (!getWorktreeMapFromState(state).has(thread.worktree.id)) {
+ const catalog = readActivityThreadWorkspaceCatalog()
+ if (!hasActivityThreadWorkspace(thread, catalog)) {
return
}
markThreadRead(thread)
- activateAndRevealWorktree(thread.worktree.id)
+ jumpToWorktreeFromSidebar(thread.worktree.id, {
+ executionHostId: getActivityThreadExecutionHostId(thread, catalog.defaultHostId)
+ })
}
- const hasUnreadThreads = allThreads.some((thread) => thread.unread)
-
const markAllThreadsRead = (): void => {
- const unreadKeys = allThreads.filter((t) => t.unread).map((t) => t.paneKey)
+ const unreadKeys = getMarkAllReadThreads()
+ .filter((t) => t.unread)
+ .map((t) => t.paneKey)
if (unreadKeys.length === 0) {
return
}
@@ -82,7 +141,7 @@ export function createActivityThreadActions({
}
return {
- hasUnreadThreads,
+ markThreadRead,
markThreadUnread,
selectThread,
jumpToWorkspace,
diff --git a/src/renderer/src/components/activity/activity-thread-builder.ts b/src/renderer/src/components/activity/activity-thread-builder.ts
index 8ba6ab4f5fd..a1076ea0022 100644
--- a/src/renderer/src/components/activity/activity-thread-builder.ts
+++ b/src/renderer/src/components/activity/activity-thread-builder.ts
@@ -9,11 +9,68 @@ import type {
AgentPaneThread
} from './activity-thread-types'
-export function buildAgentPaneThreads(args: {
- events: ActivityEvent[]
- liveAgentByPaneKey: Record
- generatedTitlesEnabled?: boolean
-}): AgentPaneThread[] {
+/**
+ * Caller-owned reuse cache: threads whose derived content is unchanged keep their
+ * previous object (and the whole list keeps its array) identity, so memo'd rows and
+ * the search-text cache survive unrelated store writes.
+ */
+export type AgentPaneThreadReuseCache = {
+ previousByPaneKey: Map
+ previousList: AgentPaneThread[]
+}
+
+export function createAgentPaneThreadReuseCache(): AgentPaneThreadReuseCache {
+ return { previousByPaneKey: new Map(), previousList: [] }
+}
+
+function arrayItemsEqual(a: readonly T[], b: readonly T[]): boolean {
+ if (a.length !== b.length) {
+ return false
+ }
+ for (let i = 0; i < a.length; i += 1) {
+ if (a[i] !== b[i]) {
+ return false
+ }
+ }
+ return true
+}
+
+// Why: event and live-snapshot identities are preserved upstream (activity-event-builder
+// cache), so identity comparison on the referenced objects is a correct change detector.
+function reuseThreadIfEqual(
+ previous: AgentPaneThread | undefined,
+ next: AgentPaneThread
+): AgentPaneThread {
+ if (
+ previous !== undefined &&
+ previous.paneKey === next.paneKey &&
+ previous.paneTitle === next.paneTitle &&
+ previous.worktree === next.worktree &&
+ previous.repo === next.repo &&
+ previous.tab === next.tab &&
+ previous.agentType === next.agentType &&
+ previous.currentAgentState === next.currentAgentState &&
+ previous.currentAgentEntry === next.currentAgentEntry &&
+ previous.responsePreview === next.responsePreview &&
+ previous.latestTimestamp === next.latestTimestamp &&
+ previous.latestEvent === next.latestEvent &&
+ previous.migrationUnsupportedPtyId === next.migrationUnsupportedPtyId &&
+ previous.unread === next.unread &&
+ arrayItemsEqual(previous.events, next.events)
+ ) {
+ return previous
+ }
+ return next
+}
+
+export function buildAgentPaneThreads(
+ args: {
+ events: ActivityEvent[]
+ liveAgentByPaneKey: Record
+ generatedTitlesEnabled?: boolean
+ },
+ reuseCache?: AgentPaneThreadReuseCache
+): AgentPaneThread[] {
const generatedTitlesEnabled = args.generatedTitlesEnabled === true
const byPaneKey = new Map()
for (const event of args.events) {
@@ -92,10 +149,22 @@ export function buildAgentPaneThreads(args: {
existing.latestTimestamp = liveAgent.timestamp
}
- return Array.from(byPaneKey.values())
- .map((thread) => ({
- ...thread,
- events: [...thread.events].sort((a, b) => b.timestamp - a.timestamp)
- }))
+ const built = Array.from(byPaneKey.values())
+ .map((thread) => {
+ const next: AgentPaneThread = {
+ ...thread,
+ events: [...thread.events].sort((a, b) => b.timestamp - a.timestamp)
+ }
+ return reuseThreadIfEqual(reuseCache?.previousByPaneKey.get(thread.paneKey), next)
+ })
.sort((a, b) => b.latestTimestamp - a.latestTimestamp)
+
+ if (!reuseCache) {
+ return built
+ }
+ // Why: keep the list's array identity too, so downstream memos keyed on the list bail out.
+ const result = arrayItemsEqual(reuseCache.previousList, built) ? reuseCache.previousList : built
+ reuseCache.previousList = result
+ reuseCache.previousByPaneKey = new Map(result.map((thread) => [thread.paneKey, thread]))
+ return result
}
diff --git a/src/renderer/src/components/activity/activity-thread-child-agent.test.ts b/src/renderer/src/components/activity/activity-thread-child-agent.test.ts
new file mode 100644
index 00000000000..7c687c72037
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-child-agent.test.ts
@@ -0,0 +1,171 @@
+import { describe, expect, it } from 'vitest'
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import { collectChildAgentPaneKeys } from './activity-thread-child-agent'
+import type { ActivityEvent, AgentPaneThread } from './activity-thread-types'
+import {
+ makeRepo,
+ makeTabWithIds,
+ makeWorkingEntryWithoutHistory,
+ makeWorktree,
+ PANE_KEY,
+ PANE_KEY_2,
+ PANE_KEY_3
+} from './ActivityPrototypePage-test-fixtures'
+
+function makeTestEntry(
+ paneKey: string,
+ overrides: Partial = {}
+): AgentStatusEntry {
+ return {
+ ...makeWorkingEntryWithoutHistory(),
+ paneKey,
+ state: 'done',
+ prompt: 'test prompt',
+ stateHistory: [],
+ ...overrides
+ }
+}
+
+function makeTestThread(
+ paneKey: string,
+ overrides: Partial = {}
+): AgentPaneThread {
+ const worktree = makeWorktree()
+ return {
+ paneKey,
+ paneTitle: 'Test Agent',
+ agentType: 'claude',
+ worktree,
+ repo: makeRepo(),
+ tab: makeTabWithIds('tab-1', worktree.id),
+ events: [],
+ latestEvent: null,
+ latestTimestamp: 1000,
+ currentAgentState: 'working',
+ currentAgentEntry: makeTestEntry(paneKey),
+ unread: false,
+ responsePreview: '',
+ ...overrides
+ }
+}
+
+function makeEventFor(entry: AgentStatusEntry): ActivityEvent {
+ const worktree = makeWorktree()
+ return {
+ id: `event-${entry.paneKey}`,
+ state: 'done',
+ timestamp: 1000,
+ unread: false,
+ worktree,
+ repo: null,
+ tab: makeTabWithIds('tab-1', worktree.id),
+ agentType: 'claude',
+ agentAlive: true,
+ entry
+ }
+}
+
+describe('collectChildAgentPaneKeys', () => {
+ it('returns an empty set when no thread carries orchestration', () => {
+ const threads = [makeTestThread(PANE_KEY), makeTestThread(PANE_KEY_2)]
+ expect(collectChildAgentPaneKeys(threads).size).toBe(0)
+ })
+
+ it('classifies a thread whose parent pane is listed as a child', () => {
+ const parent = makeTestThread(PANE_KEY)
+ const child = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([parent, child])).toEqual(new Set([PANE_KEY_2]))
+ })
+
+ it('promotes an orphan whose parent pane is no longer listed', () => {
+ const orphan = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([orphan]).size).toBe(0)
+ })
+
+ it('ignores a self-referencing parentPaneKey', () => {
+ const thread = makeTestThread(PANE_KEY, {
+ currentAgentEntry: makeTestEntry(PANE_KEY, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([thread]).size).toBe(0)
+ })
+
+ it('resolves coordinatorHandle through a listed thread terminal handle', () => {
+ const coordinator = makeTestThread(PANE_KEY, {
+ currentAgentEntry: makeTestEntry(PANE_KEY, { terminalHandle: 'terminal-coord' })
+ })
+ const worker = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ terminalHandle: 'terminal-worker',
+ orchestration: {
+ coordinatorHandle: 'terminal-coord',
+ taskId: 'task-1',
+ dispatchId: 'ctx-1'
+ }
+ })
+ })
+ expect(collectChildAgentPaneKeys([coordinator, worker])).toEqual(new Set([PANE_KEY_2]))
+ })
+
+ it('promotes a worker whose coordinator handle matches no listed thread', () => {
+ const worker = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ terminalHandle: 'terminal-worker',
+ orchestration: { coordinatorHandle: 'terminal-gone', taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([worker]).size).toBe(0)
+ })
+
+ it('keeps child classification from an older event while the parent is listed', () => {
+ const parent = makeTestThread(PANE_KEY)
+ const childEntry = makeTestEntry(PANE_KEY_2, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ const child = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2),
+ events: [makeEventFor(childEntry)]
+ })
+ expect(collectChildAgentPaneKeys([parent, child])).toEqual(new Set([PANE_KEY_2]))
+ })
+
+ it('classifies a grandchild chained through a listed child', () => {
+ const root = makeTestThread(PANE_KEY)
+ const child = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ const grandchild = makeTestThread(PANE_KEY_3, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_3, {
+ orchestration: { parentPaneKey: PANE_KEY_2, taskId: 'task-2', dispatchId: 'ctx-2' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([root, child, grandchild])).toEqual(
+ new Set([PANE_KEY_2, PANE_KEY_3])
+ )
+ })
+
+ it('promotes every member of a parent cycle instead of hiding them all', () => {
+ const a = makeTestThread(PANE_KEY, {
+ currentAgentEntry: makeTestEntry(PANE_KEY, {
+ orchestration: { parentPaneKey: PANE_KEY_2, taskId: 'task-1', dispatchId: 'ctx-1' }
+ })
+ })
+ const b = makeTestThread(PANE_KEY_2, {
+ currentAgentEntry: makeTestEntry(PANE_KEY_2, {
+ orchestration: { parentPaneKey: PANE_KEY, taskId: 'task-2', dispatchId: 'ctx-2' }
+ })
+ })
+ expect(collectChildAgentPaneKeys([a, b]).size).toBe(0)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-thread-child-agent.ts b/src/renderer/src/components/activity/activity-thread-child-agent.ts
new file mode 100644
index 00000000000..4fd0a3dbd10
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-child-agent.ts
@@ -0,0 +1,90 @@
+import type { AgentStatusEntry } from '../../../../shared/agent-status-types'
+import {
+ buildAgentRowLineageTree,
+ resolveAgentRowParentPaneKey,
+ type AgentLineageSourceRow
+} from '../dashboard/agent-row-lineage-model'
+
+type ChildAgentLineageEntry = Pick
+
+/** Minimal structural input: a full AgentPaneThread satisfies it (pinned by the
+ * classifier tests), and count/badge callers can feed synthetic rows uncast. */
+export type ChildAgentClassifiableThread = {
+ paneKey: string
+ currentAgentEntry?: ChildAgentLineageEntry | null
+ latestEvent?: { entry: ChildAgentLineageEntry } | null
+ events?: readonly { entry: ChildAgentLineageEntry }[]
+}
+
+/** Every entry that can carry the pane's orchestration lineage, newest first. */
+function candidateEntries(thread: ChildAgentClassifiableThread): ChildAgentLineageEntry[] {
+ const entries: ChildAgentLineageEntry[] = []
+ if (thread.currentAgentEntry) {
+ entries.push(thread.currentAgentEntry)
+ }
+ if (thread.latestEvent?.entry) {
+ entries.push(thread.latestEvent.entry)
+ }
+ for (const event of thread.events ?? []) {
+ entries.push(event.entry)
+ }
+ return entries
+}
+
+function firstReportedTerminalHandle(thread: ChildAgentClassifiableThread): string | undefined {
+ for (const entry of candidateEntries(thread)) {
+ if (entry.terminalHandle) {
+ return entry.terminalHandle
+ }
+ }
+ return undefined
+}
+
+/**
+ * Pane keys of threads that are children of another currently listed thread.
+ * Delegates to the dashboard's lineage model so both surfaces classify the same
+ * pane identically: a parent reference only counts while the parent thread is
+ * still listed, so orphaned workers (their coordinator pane closed) and cycle
+ * members are promoted to top level instead of staying hidden behind the
+ * child-agent filter. Classification is sticky across a thread's older events:
+ * the newest entry whose parent still resolves wins.
+ */
+export function collectChildAgentPaneKeys(
+ threads: readonly ChildAgentClassifiableThread[]
+): Set {
+ const baseRows: AgentLineageSourceRow[] = threads.map((thread) => ({
+ paneKey: thread.paneKey,
+ entry: { terminalHandle: firstReportedTerminalHandle(thread) }
+ }))
+ const rowsByPaneKey = new Map()
+ for (const row of baseRows) {
+ if (!rowsByPaneKey.has(row.paneKey)) {
+ rowsByPaneKey.set(row.paneKey, row)
+ }
+ }
+ const paneKeyByTerminalHandle = new Map()
+ for (const row of baseRows) {
+ if (row.entry.terminalHandle && !paneKeyByTerminalHandle.has(row.entry.terminalHandle)) {
+ paneKeyByTerminalHandle.set(row.entry.terminalHandle, row.paneKey)
+ }
+ }
+
+ const rows = threads.map((thread, index) => {
+ const base = baseRows[index]
+ for (const entry of candidateEntries(thread)) {
+ if (!entry.orchestration) {
+ continue
+ }
+ const probe: AgentLineageSourceRow = {
+ paneKey: thread.paneKey,
+ entry: { terminalHandle: base.entry.terminalHandle, orchestration: entry.orchestration }
+ }
+ if (resolveAgentRowParentPaneKey(probe, rowsByPaneKey, paneKeyByTerminalHandle)) {
+ return probe
+ }
+ }
+ return base
+ })
+
+ return buildAgentRowLineageTree(rows).childPaneKeys
+}
diff --git a/src/renderer/src/components/activity/activity-thread-collapse-context.ts b/src/renderer/src/components/activity/activity-thread-collapse-context.ts
new file mode 100644
index 00000000000..070b395174d
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-collapse-context.ts
@@ -0,0 +1,13 @@
+import { createContext } from 'react'
+
+export type ActivityThreadCollapseState = {
+ collapsedGroupKeys: ReadonlySet
+ onToggleGroupCollapse: (groupKey: string) => void
+}
+
+/**
+ * Caller-owned collapse state for ActivityThreadListPane hosts that unmount the
+ * pane (sidebar body switches) but should keep the user's collapsed groups.
+ * Explicit collapsedGroupKeys/onToggleGroupCollapse props take precedence.
+ */
+export const ActivityThreadCollapseContext = createContext(null)
diff --git a/src/renderer/src/components/activity/activity-thread-controls.tsx b/src/renderer/src/components/activity/activity-thread-controls.tsx
index f6cb249c9fc..ad52cd9c51c 100644
--- a/src/renderer/src/components/activity/activity-thread-controls.tsx
+++ b/src/renderer/src/components/activity/activity-thread-controls.tsx
@@ -1,17 +1,11 @@
import React from 'react'
-import { MoreVertical } from 'lucide-react'
+import { ChevronDown } from 'lucide-react'
import { AgentStateDot } from '@/components/AgentStateDot'
-import { Button } from '@/components/ui/button'
-import {
- DropdownMenu,
- DropdownMenuCheckboxItem,
- DropdownMenuContent,
- DropdownMenuItem,
- DropdownMenuSeparator,
- DropdownMenuTrigger
-} from '@/components/ui/dropdown-menu'
import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
import { translate } from '@/i18n/i18n'
+import { useNow } from '@/hooks/use-now'
+import { cn } from '@/lib/utils'
+import { formatShortTimeAgo } from '@/lib/short-time-ago'
import { RepoBadgeMark } from '@/components/repo/RepoBadgeLabel'
import type { Repo } from '../../../../shared/repo-types'
import {
@@ -22,18 +16,33 @@ import {
} from './activity-thread-presentation'
import type { ActivityThreadGroup, AgentPaneThread } from './activity-thread-types'
-export function EventTime({ timestamp }: { timestamp: number }): React.JSX.Element {
+export { ActivityThreadOptionsMenu } from './activity-thread-options-menu'
+
+export function EventTime({
+ timestamp,
+ compact = false
+}: {
+ timestamp: number
+ compact?: boolean
+}): React.JSX.Element {
+ // Why: rows reuse their identity across store writes, so this label can't rely on
+ // incidental re-renders to stay honest; the shared visibility-gated clock re-renders
+ // only this leaf (memo'd rows stay bailed out). 30s cadence matches WorktreeCardAgents.
+ const now = useNow(30_000)
const absolute = formatAbsoluteDate(timestamp)
return (
@@ -43,60 +52,6 @@ export function EventTime({ timestamp }: { timestamp: number }): React.JSX.Eleme
)
}
-export function ActivityThreadOptionsMenu({
- compactMode,
- hasUnreadThreads,
- onCompactModeChange,
- onMarkAllThreadsRead
-}: {
- compactMode: boolean
- hasUnreadThreads: boolean
- onCompactModeChange: (compactMode: boolean) => void
- onMarkAllThreadsRead: () => void
-}): React.JSX.Element {
- return (
-
-
-
- {/* Why: keep Tooltip and Dropdown from composing refs onto the same button (Radix setRef crash loop). */}
-
-
-
-
-
-
-
- {translate('auto.components.activity.ActivityPrototypePage.a472a14700', 'More options')}
-
-
-
- onCompactModeChange(checked === true)}
- onSelect={(event) => event.preventDefault()}
- >
- {translate('auto.components.activity.ActivityPrototypePage.f70e4bec47', 'Compact mode')}
-
-
- {translate('auto.components.activity.ActivityPrototypePage.023ff75afe', 'Mark all read')}
-
-
-
- )
-}
-
export function ActivityProjectLabel({ repo }: { repo: Repo | null }): React.JSX.Element {
const label =
repo?.displayName?.trim() ||
@@ -150,21 +105,54 @@ export function ThreadAgentStateIndicator({
}
export function ActivityStatusGroupHeader({
- group
+ group,
+ collapsed = false,
+ onToggle,
+ className
}: {
group: ActivityThreadGroup
+ collapsed?: boolean
+ onToggle?: () => void
+ className?: string
}): React.JSX.Element {
+ const isInteractive = Boolean(onToggle)
return (
-
+ {agentsVisibleHostIds ? (
+ setAgentsVisibleHostIds(null)}
+ />
+ ) : null}
+ {hasRepoFilter ? (
+ setAgentsFilterRepoIds([])}
+ />
+ ) : null}
+
+ )
+}
diff --git a/src/renderer/src/components/activity/activity-scope-filter.test.ts b/src/renderer/src/components/activity/activity-scope-filter.test.ts
new file mode 100644
index 00000000000..45817e50a7b
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-scope-filter.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest'
+import { LOCAL_EXECUTION_HOST_ID, type ExecutionHostId } from '../../../../shared/execution-host'
+import type { Repo } from '../../../../shared/repo-types'
+import {
+ filterThreadsByActivityScope,
+ resolveActivityScopeRepoIds,
+ threadMatchesActivityScope,
+ type ActivityScopeFilter
+} from './activity-scope-filter'
+import type { AgentPaneThread } from './activity-thread-types'
+import {
+ makeRepo,
+ makeTabWithIds,
+ makeWorktree,
+ PANE_KEY
+} from './ActivityPrototypePage-test-fixtures'
+
+const SSH_HOST = 'ssh:devbox' as ExecutionHostId
+
+function makeThread(overrides: Partial
+ ()
for (const thread of threads) {
@@ -74,7 +81,7 @@ export function buildActivityThreadGroups(
return groups
}
-function threadStatusGroupId(thread: AgentPaneThread): ActivityStatusGroupId {
+export function threadStatusGroupId(thread: AgentPaneThread): ActivityStatusGroupId {
const state = threadAgentState(thread)
if (!thread.currentAgentState && state === 'done' && thread.latestEvent?.entry.interrupted) {
return 'interrupted'
@@ -118,7 +125,7 @@ export function groupActivityThreadsByStatus(threads: AgentPaneThread[]): Activi
})
}
-function threadSearchText(thread: AgentPaneThread): string {
+function buildThreadSearchText(thread: AgentPaneThread): string {
const latest = thread.latestEvent
const stateLabel = threadAgentStateLabel(thread)
const currentPrompt = thread.currentAgentEntry
@@ -132,6 +139,28 @@ function threadSearchText(thread: AgentPaneThread): string {
return `${thread.paneTitle} ${getActivityThreadWorkspaceTitle(thread.worktree)} ${thread.worktree.branch ?? ''} ${thread.repo?.displayName ?? ''} ${formatAgentTypeLabel(thread.agentType)} ${stateLabel} ${currentPrompt} ${rawCurrentPrompt} ${currentSummary} ${thread.responsePreview} ${latestEventText}`.toLowerCase()
}
+// Why: thread objects are rebuilt only when the underlying store data changes, so their
+// identity is a correct cache key; without this every keystroke re-lowercases a large
+// string per thread. WeakMap so dropped threads release their text.
+const threadSearchTextCache = new WeakMap()
+let threadSearchTextComputeCount = 0
+
+/** Test hook: how many times search text was actually (re)built. */
+export function getThreadSearchTextComputeCount(): number {
+ return threadSearchTextComputeCount
+}
+
+function threadSearchText(thread: AgentPaneThread): string {
+ const cached = threadSearchTextCache.get(thread)
+ if (cached !== undefined) {
+ return cached
+ }
+ threadSearchTextComputeCount += 1
+ const text = buildThreadSearchText(thread)
+ threadSearchTextCache.set(thread, text)
+ return text
+}
+
export const ACTIVITY_SEARCH_QUERY_MAX_BYTES = 2 * 1024
export function isActivitySearchQueryTooLarge(
diff --git a/src/renderer/src/components/activity/activity-thread-hover-card-summary.tsx b/src/renderer/src/components/activity/activity-thread-hover-card-summary.tsx
new file mode 100644
index 00000000000..37b0658f0d9
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-hover-card-summary.tsx
@@ -0,0 +1,230 @@
+import React, { useCallback, useMemo } from 'react'
+import { Cloud, Copy, FolderGit2, GitBranch, Laptop, LocateFixed, Server } from 'lucide-react'
+import { toast } from 'sonner'
+import { useAppStore } from '@/store'
+import { RepoBadgeMark } from '@/components/repo/RepoBadgeLabel'
+import { AgentIcon } from '@/lib/agent-catalog'
+import { agentTypeToIconAgent, formatAgentTypeLabel } from '@/lib/agent-status'
+import { getWorktreeGitIdentityDisplay } from '@/lib/worktree-git-identity-display'
+import { jumpToWorktreeFromSidebar } from '@/lib/worktree-jump-navigation'
+import { translate } from '@/i18n/i18n'
+import { cn } from '@/lib/utils'
+import {
+ getExecutionHostLabel,
+ getWorktreeExecutionHostId,
+ parseExecutionHostId
+} from '../../../../shared/execution-host'
+import type { GlobalSettings } from '../../../../shared/global-settings-types'
+import { getHostDisplayLabelOverrides } from '../../../../shared/host-setting-overrides'
+import CommentMarkdown from '../sidebar/CommentMarkdown'
+import { DetailHeader, MetadataActionIcon } from '../sidebar/WorktreeCardMetadataControls'
+import {
+ WorktreeCardDetailSection,
+ WorktreeCardDetailSectionContent
+} from '../sidebar/WorktreeCardDetailSection'
+import { EventTime, ThreadAgentStateIndicator } from './activity-thread-controls'
+import { activityThreadRowCopy, threadAgentStateLabel } from './activity-thread-presentation'
+import { getActivityThreadWorkspaceTitle } from '@/lib/activity-thread-display'
+import type { AgentPaneThread } from './activity-thread-types'
+
+export function ActivityThreadHoverCardSummary({
+ thread,
+ settings,
+ onJumpToWorkspace,
+ canJumpToWorkspace
+}: {
+ thread: AgentPaneThread
+ settings: GlobalSettings | null | undefined
+ onJumpToWorkspace?: (event: React.MouseEvent) => void
+ canJumpToWorkspace?: boolean
+}): React.JSX.Element {
+ const { worktree, repo } = thread
+ const sshTargetLabels = useAppStore((s) => s.sshTargetLabels)
+ const runtimeEnvironments = useAppStore((s) => s.runtimeEnvironments)
+ const executionHostId = getWorktreeExecutionHostId(worktree, repo ?? undefined)
+ const parsedHost = parseExecutionHostId(executionHostId)
+ const hostLabelOverrides = useMemo(() => getHostDisplayLabelOverrides(settings), [settings])
+ const hostDisplayLabel = useMemo(() => {
+ const override = hostLabelOverrides.get(executionHostId)
+ if (override) {
+ return override
+ }
+ if (parsedHost?.kind === 'runtime') {
+ const environment = runtimeEnvironments.find((entry) => entry.id === parsedHost.environmentId)
+ if (environment?.name) {
+ return environment.name
+ }
+ }
+ if (parsedHost?.kind === 'ssh') {
+ const target = sshTargetLabels.get(parsedHost.targetId)
+ if (target) {
+ return target
+ }
+ }
+ return getExecutionHostLabel(executionHostId)
+ }, [executionHostId, hostLabelOverrides, parsedHost, runtimeEnvironments, sshTargetLabels])
+ const branchIdentityDisplay = useMemo(() => getWorktreeGitIdentityDisplay(worktree), [worktree])
+ const { taskTitle, needsAttention } = activityThreadRowCopy(thread)
+ const workspaceTitle = getActivityThreadWorkspaceTitle(worktree)
+ const copyPathLabel = translate(
+ 'auto.components.activity.ActivityThreadHoverCard.copyPath',
+ 'Copy path'
+ )
+
+ const isKnownWorktree = useAppStore((s) =>
+ Boolean(s.getKnownWorktreeById(worktree.id, executionHostId))
+ )
+ const canJump = canJumpToWorkspace ?? isKnownWorktree
+
+ const handleJumpToWorkspace = useCallback(
+ (event: React.MouseEvent) => {
+ event.stopPropagation()
+ if (onJumpToWorkspace) {
+ onJumpToWorkspace(event)
+ } else {
+ const state = useAppStore.getState()
+ if (state.getKnownWorktreeById(worktree.id, executionHostId)) {
+ state.acknowledgeAgents([thread.paneKey])
+ jumpToWorktreeFromSidebar(worktree.id, { executionHostId })
+ }
+ }
+ },
+ [executionHostId, onJumpToWorkspace, thread.paneKey, worktree.id]
+ )
+
+ const handleCopyPath = useCallback(async () => {
+ if (!worktree.path) {
+ return
+ }
+ try {
+ await window.api.ui.writeClipboardText(worktree.path)
+ toast.success(
+ translate(
+ 'auto.components.activity.ActivityThreadHoverCard.pathCopied',
+ 'Path copied to clipboard'
+ )
+ )
+ } catch {
+ toast.error(
+ translate(
+ 'auto.components.activity.ActivityThreadHoverCard.copyPathFailed',
+ 'Failed to copy path'
+ )
+ )
+ }
+ }, [worktree.path])
+
+ return (
+ <>
+
+
+
+ ) : null
+ }
+ />
+
+
+
+
+ )
+}
diff --git a/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx b/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
new file mode 100644
index 00000000000..0e604a16098
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-hover-card.test.tsx
@@ -0,0 +1,238 @@
+// @vitest-environment happy-dom
+
+import React, { act, type ReactElement, type ReactNode } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { TooltipProvider } from '@/components/ui/tooltip'
+import type { Worktree } from '../../../../shared/worktree/types'
+import { ActivityThreadHoverCard } from './activity-thread-hover-card'
+import { ActivityThreadRow } from './activity-thread-row'
+import type { AgentPaneThread } from './activity-thread-types'
+import { makeRepo, makeTab, makeWorktree } from './ActivityPrototypePage-test-fixtures'
+
+vi.mock('@/components/ui/hover-card', () => ({
+ HoverCard: ({
+ children,
+ onOpenChange
+ }: {
+ children: ReactNode
+ onOpenChange?: (open: boolean) => void
+ }) => {
+ React.useEffect(() => onOpenChange?.(true), [onOpenChange])
+ return <>{children}
+ },
+ HoverCardContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+ = {}): AgentPaneThread {
+ const repo = makeRepo()
+ const worktree: Worktree = {
+ ...makeWorktree(),
+ displayName: 'm4air-audit',
+ branch: 'feat/m4air-performance',
+ path: '/Users/test/projects/orca/worktrees/m4air-audit',
+ comment: 'Notes for performance audit',
+ hostId: 'runtime:m4air-env-id' as const
+ }
+ const tab = makeTab()
+
+ return {
+ paneKey: 'tab-1:leaf-1',
+ tab,
+ worktree,
+ repo,
+ agentType: 'claude',
+ latestEvent: null,
+ currentAgentState: 'working',
+ currentAgentEntry: null,
+ events: [],
+ unread: false,
+ paneTitle: 'Audit current HEAD on m4air environment',
+ responsePreview: 'Auditing terminal PTY and IME bug categories...',
+ latestTimestamp: 1700000000000,
+ ...overrides
+ }
+}
+
+function Harness({
+ thread,
+ selected = false,
+ onSelect = vi.fn(),
+ onJump = vi.fn(),
+ onMarkRead = vi.fn(),
+ onMarkUnread = vi.fn()
+}: {
+ thread: AgentPaneThread
+ selected?: boolean
+ onSelect?: () => void
+ onJump?: () => void
+ onMarkRead?: () => void
+ onMarkUnread?: () => void
+}): ReactElement {
+ return (
+
+
+ )
+}
+
+describe('ActivityThreadHoverCard and ActivityThreadRow', () => {
+ let container: HTMLDivElement
+ let root: Root
+
+ beforeEach(() => {
+ container = document.createElement('div')
+ document.body.appendChild(container)
+ root = createRoot(container)
+ })
+
+ afterEach(() => {
+ act(() => root.unmount())
+ container.remove()
+ document.body.replaceChildren()
+ })
+
+ it('renders the thread row with task title and workspace label', async () => {
+ const thread = createTestThread()
+
+ await act(async () => {
+ root.render((
+ 'button[aria-label="Mark thread as read"]'
+ )
+ expect(markReadButton).not.toBeNull()
+
+ act(() => {
+ markReadButton?.click()
+ })
+
+ expect(onMarkRead).toHaveBeenCalledWith(thread)
+ expect(onSelect).not.toHaveBeenCalled()
+ })
+
+ it('renders hover card content with workspace info, host, task details, and notes', async () => {
+ const thread = createTestThread({
+ worktree: {
+ ...makeWorktree(),
+ displayName: 'm4air-audit',
+ branch: 'feat/m4air-performance',
+ path: '/Users/test/projects/orca/worktrees/m4air-audit',
+ comment: 'Performance investigation notes',
+ hostId: 'runtime:m4air-env' as const
+ }
+ })
+
+ await act(async () => {
+ root.render(
+
+
+
+
+ )
+ })
+
+ const content = container.querySelector('[data-testid="hover-card-content"]')?.textContent ?? ''
+
+ // Workspace & Host info
+ expect(content).toContain('Workspace')
+ expect(content).toContain('m4air-audit')
+ expect(content).toContain('feat/m4air-performance')
+ expect(content).toContain('/Users/test/projects/orca/worktrees/m4air-audit')
+
+ // Agent & Task details
+ expect(content).toContain('Claude')
+ expect(content).toContain('Audit current HEAD on m4air environment')
+ expect(content).toContain('Auditing terminal PTY and IME bug categories...')
+
+ // Notes
+ expect(content).toContain('Notes')
+ expect(content).toContain('Performance investigation notes')
+ })
+
+ it('allows clicking row while preventing inner hover interactions from bubbling', async () => {
+ const onSelect = vi.fn()
+ const thread = createTestThread()
+
+ await act(async () => {
+ root.render(('[data-worktree-card-surface="true"]')
+ expect(card).not.toBeNull()
+
+ await act(async () => {
+ card?.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+ })
+
+ expect(onSelect).toHaveBeenCalledTimes(1)
+ })
+
+ it('triggers jump to workspace from the hover card crosshair locator button', async () => {
+ const onJump = vi.fn()
+ const thread = createTestThread()
+
+ await act(async () => {
+ root.render(
+
+
+
+
+ )
+ })
+
+ const jumpButton = container.querySelector(
+ 'button[aria-label="Jump to workspace"]'
+ )
+ expect(jumpButton).not.toBeNull()
+
+ act(() => {
+ jumpButton?.click()
+ })
+
+ expect(onJump).toHaveBeenCalledWith(thread)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-thread-hover-card.tsx b/src/renderer/src/components/activity/activity-thread-hover-card.tsx
new file mode 100644
index 00000000000..9bb4ed83887
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-hover-card.tsx
@@ -0,0 +1,407 @@
+import React, { useCallback } from 'react'
+import { ExternalLink, MonitorUp, Pencil, StickyNote } from 'lucide-react'
+import { toast } from 'sonner'
+import { Badge } from '@/components/ui/badge'
+import { HoverCard, HoverCardContent, HoverCardTrigger } from '@/components/ui/hover-card'
+import { LinearIcon } from '@/components/icons/LinearIcon'
+import { JiraIcon } from '@/components/icons/JiraIcon'
+import { SelectedTextCopyMenu } from '@/components/SelectedTextCopyMenu'
+import { translate } from '@/i18n/i18n'
+import CommentMarkdown from '../sidebar/CommentMarkdown'
+import { DetailHeader, MetadataActionIcon } from '../sidebar/WorktreeCardMetadataControls'
+import {
+ WorktreeCardDetailSection,
+ WorktreeCardDetailSectionContent
+} from '../sidebar/WorktreeCardDetailSection'
+import { LinearStateBadge } from '../sidebar/WorktreeCardMetadataStatusBadges'
+import { WorktreeCardIssueDetailSection } from '../sidebar/WorktreeCardIssueDetailSection'
+import { WorktreeCardReviewDetailSection } from '../sidebar/WorktreeCardReviewDetailSection'
+import { WorktreeCardAutomationDetailSection } from '../sidebar/WorktreeCardAutomationDetailSection'
+import { WorktreeCardCliDetailSection } from '../sidebar/WorktreeCardCliDetailSection'
+import { WorktreeCardPortsDetails } from '../sidebar/WorktreeCardPorts'
+import { WORKTREE_NATIVE_CONTEXT_MENU_ATTR } from '../sidebar/WorktreeContextMenu'
+import { useWorktreeCardDetailsHoverControl } from '../sidebar/worktree-card-details-hover-state'
+import { useWorktreeCardFoundation } from '../sidebar/use-worktree-card-foundation'
+import { useWorktreeCardReviewDetails } from '../sidebar/use-worktree-card-review-details'
+import { useWorktreeCardLinkedDetails } from '../sidebar/use-worktree-card-linked-details'
+import { useWorktreeCardLifecycleEffects } from '../sidebar/use-worktree-card-lifecycle-effects'
+import { useWorktreeCardSecondaryDetails } from '../sidebar/use-worktree-card-secondary-details'
+import { getReviewLabel } from '../sidebar/worktree-review-helpers'
+import { ActivityThreadHoverCardSummary } from './activity-thread-hover-card-summary'
+import type { AgentPaneThread } from './activity-thread-types'
+
+export type ActivityThreadHoverCardProps = {
+ thread: AgentPaneThread
+ children: React.ReactElement
+ openDelay?: number
+ closeDelay?: number
+ onJumpToWorkspace?: (thread: AgentPaneThread) => void
+ canJumpToWorkspace?: boolean
+}
+
+export function ActivityThreadHoverCard({
+ thread,
+ children,
+ openDelay = 200,
+ closeDelay = 120,
+ onJumpToWorkspace,
+ canJumpToWorkspace
+}: ActivityThreadHoverCardProps): React.JSX.Element {
+ const detailsHoverControl = useWorktreeCardDetailsHoverControl()
+
+ return (
+
+ {children}
+ {detailsHoverControl.hoverOpen ? (
+
+ )
+}
+
+function ActivityThreadHoverCardContent({
+ thread,
+ detailsHoverControl,
+ onJumpToWorkspace,
+ canJumpToWorkspace
+}: {
+ thread: AgentPaneThread
+ detailsHoverControl: ReturnType
+ onJumpToWorkspace?: (thread: AgentPaneThread) => void
+ canJumpToWorkspace?: boolean
+}): React.JSX.Element {
+ const { worktree, repo } = thread
+ const foundation = useWorktreeCardFoundation({ worktree, repo: repo ?? undefined })
+ const review = useWorktreeCardReviewDetails({
+ worktree,
+ repo: repo ?? undefined,
+ settings: foundation.settings,
+ projectGroups: foundation.projectGroups,
+ cardProps: foundation.cardProps,
+ newCardStyle: foundation.newCardStyle
+ })
+ const linked = useWorktreeCardLinkedDetails({
+ worktree,
+ newCardStyle: foundation.newCardStyle,
+ deleteState: foundation.deleteState,
+ branch: review.branch,
+ issueEntry: review.issueEntry,
+ linearIssueEntry: review.linearIssueEntry,
+ linearIssueFallbackEntry: review.linearIssueFallbackEntry,
+ prDisplay: review.prDisplay
+ })
+
+ const hoverDetailsOpen = detailsHoverControl.hoverOpen
+
+ useWorktreeCardLifecycleEffects({
+ worktree,
+ repo: repo ?? undefined,
+ isFolder: review.isFolder,
+ hostedReviewCacheKey: review.hostedReviewCacheKey,
+ cachedBranchFallbackGitHubPRNumber: review.cachedBranchFallbackGitHubPRNumber,
+ linkedGitLabMR: review.linkedGitLabMR,
+ linkedBitbucketPR: review.linkedBitbucketPR,
+ linkedAzureDevOpsPR: review.linkedAzureDevOpsPR,
+ linkedGiteaPR: review.linkedGiteaPR,
+ branch: review.branch,
+ fetchHostedReviewForBranch: foundation.fetchHostedReviewForBranch,
+ shouldRefreshHostedReview: false,
+ newCardStyle: true,
+ hoverDetailsOpen,
+ showIssue: true,
+ issueCacheKey: review.issueCacheKey,
+ fetchIssue: foundation.fetchIssue,
+ showLinearIssue: true,
+ fetchLinearIssue: foundation.fetchLinearIssue
+ })
+
+ const secondary = useWorktreeCardSecondaryDetails({
+ worktree,
+ repo: repo ?? undefined,
+ statusPrDisplay: null,
+ showStatus: true,
+ showIssue: true,
+ showLinearIssue: true,
+ showJiraIssue: true,
+ showPR: true,
+ showAutomation: true,
+ showCli: true,
+ showComment: true,
+ showPorts: true,
+ issueDisplay: linked.issueDisplay,
+ linearIssue: linked.linearIssue,
+ linearIssueDisplay: linked.linearIssueDisplay,
+ jiraIssueDisplay: linked.jiraIssueDisplay,
+ prDisplay: review.prDisplay,
+ linkedGitLabMR: review.linkedGitLabMR,
+ linkedBitbucketPR: review.linkedBitbucketPR,
+ linkedAzureDevOpsPR: review.linkedAzureDevOpsPR,
+ linkedGiteaPR: review.linkedGiteaPR,
+ cardProps: foundation.cardProps,
+ newCardStyle: foundation.newCardStyle,
+ compactCards: foundation.compactCards,
+ agentActivityDisplayMode: foundation.agentActivityDisplayMode,
+ workspacePorts: foundation.workspacePorts,
+ openTaskPage: foundation.openTaskPage,
+ updateWorktreeMeta: foundation.updateWorktreeMeta,
+ settings: foundation.settings
+ })
+
+ const copyLinkedWorkItemLink = useCallback(async (url: string, label: string) => {
+ try {
+ await window.api.ui.writeClipboardText(url)
+ toast.success(
+ translate('auto.components.sidebar.WorktreeCardMeta.copyLinkSuccess', '{{value0}} copied', {
+ value0: label
+ })
+ )
+ } catch {
+ toast.error(
+ translate('auto.components.sidebar.WorktreeCardMeta.copyLinkFailure', 'Failed to copy link')
+ )
+ }
+ }, [])
+
+ const handleCopyIssueLink = useCallback(() => {
+ if (!secondary.hoverIssue?.url) {
+ return
+ }
+ detailsHoverControl.closeHover()
+ void copyLinkedWorkItemLink(
+ secondary.hoverIssue.url,
+ translate('auto.components.sidebar.WorktreeCardMeta.issueLinkLabel', 'Issue link')
+ )
+ }, [copyLinkedWorkItemLink, detailsHoverControl, secondary.hoverIssue?.url])
+
+ const handleCopyReviewLink = useCallback(() => {
+ if (!secondary.hoverReview?.url) {
+ return
+ }
+ void copyLinkedWorkItemLink(
+ secondary.hoverReview.url,
+ translate('auto.components.sidebar.WorktreeCardMeta.reviewLinkLabel', '{{value0}} link', {
+ value0: getReviewLabel(secondary.hoverReview)
+ })
+ )
+ }, [copyLinkedWorkItemLink, secondary.hoverReview])
+
+ const dismissAndRun = useCallback(
+ (handler: ((event: React.MouseEvent) => void) | undefined) => (event: React.MouseEvent) => {
+ detailsHoverControl.closeHover()
+ handler?.(event)
+ },
+ [detailsHoverControl]
+ )
+
+ return (
+ event.stopPropagation()}
+ onDoubleClick={(event) => event.stopPropagation()}
+ >
+
+ onJumpToWorkspace(thread)) : undefined
+ }
+ canJumpToWorkspace={canJumpToWorkspace}
+ />
+
+ {/* GitHub / GitLab Issue */}
+ {
+ detailsHoverControl.closeHover()
+ secondary.handleOpenIssueInBrowser(url)
+ }
+ : undefined
+ }
+ />
+
+ {/* Linear Issue */}
+ {secondary.hoverLinearIssue && (
+
+
+
+ )}
+ {secondary.hoverLinearIssue.url && (
+
+
+ )}
+
+ }
+ />
+
+
+
+ )}
+
+ {/* Jira Issue */}
+ {secondary.hoverJiraIssue && (
+
+
+
+ }
+ />
+
+
+
+ )}
+
+ {/* Pull Request / Review */}
+
+
+
+ }
+ />
+
+
+
+ )}
+
+ {/* Ports */}
+ {foundation.workspacePorts.length > 0 && (
+
+
+ )
+}
diff --git a/src/renderer/src/components/activity/activity-thread-list-pane-collapsible.test.tsx b/src/renderer/src/components/activity/activity-thread-list-pane-collapsible.test.tsx
new file mode 100644
index 00000000000..6db25785dc6
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-list-pane-collapsible.test.tsx
@@ -0,0 +1,292 @@
+// @vitest-environment happy-dom
+
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { TooltipProvider } from '@/components/ui/tooltip'
+import { ActivityStatusGroupHeader } from './activity-thread-controls'
+import { ActivityThreadListPane } from './activity-thread-list-pane'
+import type { ActivityThreadGroup, AgentPaneThread } from './activity-thread-types'
+import { makeTab, makeWorktree } from './ActivityPrototypePage-test-fixtures'
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+
+const mockThread: AgentPaneThread = {
+ paneKey: 'tab-1:agent-1',
+ tab: makeTab(),
+ worktree: makeWorktree(),
+ repo: null,
+ currentAgentState: null,
+ currentAgentEntry: null,
+ latestEvent: null,
+ latestTimestamp: 1000,
+ agentType: 'claude',
+ unread: false,
+ paneTitle: 'Test agent',
+ responsePreview: 'Done testing',
+ events: []
+}
+
+const mockGroup: ActivityThreadGroup = {
+ key: 'done',
+ label: 'Done',
+ state: 'done',
+ threads: [mockThread]
+}
+
+describe('ActivityStatusGroupHeader', () => {
+ let container: HTMLDivElement
+ let root: Root
+
+ beforeEach(() => {
+ container = document.createElement('div')
+ document.body.appendChild(container)
+ root = createRoot(container)
+ })
+
+ afterEach(() => {
+ act(() => root.unmount())
+ container.remove()
+ document.body.replaceChildren()
+ })
+
+ it('renders group label, count, and expanded state', () => {
+ const onToggle = vi.fn()
+ act(() => {
+ root.render(
+
+
+ )
+ })
+
+ const header = container.querySelector('[role="button"]')
+ expect(header).not.toBeNull()
+ expect(header?.getAttribute('aria-expanded')).toBe('true')
+ expect(header?.textContent).toContain('Done')
+ expect(header?.textContent).toContain('1')
+ })
+
+ it('triggers onToggle on click and on keydown (Enter / Space)', () => {
+ const onToggle = vi.fn()
+ act(() => {
+ root.render(
+
+
+ )
+ })
+
+ const header = container.querySelector('[role="button"]') as HTMLElement
+ act(() => {
+ header.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+ })
+ expect(onToggle).toHaveBeenCalledTimes(1)
+
+ act(() => {
+ header.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+ })
+ expect(onToggle).toHaveBeenCalledTimes(2)
+
+ act(() => {
+ header.dispatchEvent(new KeyboardEvent('keydown', { key: ' ', bubbles: true }))
+ })
+ expect(onToggle).toHaveBeenCalledTimes(3)
+ })
+
+ it('renders collapsed state with aria-expanded false', () => {
+ const onToggle = vi.fn()
+ act(() => {
+ root.render(
+
+
+ )
+ })
+
+ const header = container.querySelector('[role="button"]')
+ expect(header?.getAttribute('aria-expanded')).toBe('false')
+ })
+
+ it('supports custom className and uses accessible contrast tokens without hardcoded white background', () => {
+ act(() => {
+ root.render(
+
+
+ )
+ })
+
+ const header = container.querySelector('div')
+ expect(header?.className).toContain('custom-header-class')
+ expect(header?.className).not.toContain('bg-background/95')
+ })
+})
+
+describe('ActivityThreadListPane collapsible sections', () => {
+ let container: HTMLDivElement
+ let root: Root
+
+ beforeEach(() => {
+ container = document.createElement('div')
+ document.body.appendChild(container)
+ root = createRoot(container)
+ })
+
+ afterEach(() => {
+ act(() => root.unmount())
+ container.remove()
+ document.body.replaceChildren()
+ })
+
+ it('toggles thread visibility when header is clicked in uncontrolled mode', () => {
+ const inputRef = { current: null }
+ act(() => {
+ root.render(
+
+ true}
+ showFilterControls={false}
+ showOptionsMenu={false}
+ />
+
+ )
+ })
+
+ // Initially open: thread row should be visible
+ expect(container.textContent).toContain('Test agent')
+
+ // Click header to collapse
+ const header = container.querySelector('[role="button"]') as HTMLElement
+ act(() => {
+ header.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+ })
+
+ // Thread row should now be hidden
+ expect(container.textContent).not.toContain('Test agent')
+ expect(header.getAttribute('aria-expanded')).toBe('false')
+
+ // Click header again to re-expand
+ act(() => {
+ header.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+ })
+
+ expect(container.textContent).toContain('Test agent')
+ expect(header.getAttribute('aria-expanded')).toBe('true')
+ })
+
+ it('respects controlled collapsedGroupKeys and invokes onToggleGroupCollapse', () => {
+ const inputRef = { current: null }
+ const onToggleGroup = vi.fn()
+ act(() => {
+ root.render(
+
+ true}
+ showFilterControls={false}
+ showOptionsMenu={false}
+ collapsedGroupKeys={new Set(['done'])}
+ onToggleGroupCollapse={onToggleGroup}
+ />
+
+ )
+ })
+
+ // Controlled as collapsed: thread row should not be rendered
+ expect(container.textContent).not.toContain('Test agent')
+
+ // Click header
+ const header = container.querySelector('[role="button"]') as HTMLElement
+ act(() => {
+ header.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+ })
+
+ expect(onToggleGroup).toHaveBeenCalledWith('done')
+ })
+
+ it('keeps mark-unread enabled for the thread whose terminal pane is selected', () => {
+ const inputRef = { current: null }
+ const onMarkThreadUnread = vi.fn()
+ act(() => {
+ root.render(
+
+ true}
+ allowMarkUnreadWhenSelected
+ showFilterControls={false}
+ showOptionsMenu={false}
+ />
+
+ )
+ })
+
+ const markUnreadButton = container.querySelector(
+ 'button[aria-label="Mark thread unread"]'
+ ) as HTMLButtonElement | null
+ expect(markUnreadButton).not.toBeNull()
+ expect(markUnreadButton?.disabled).toBe(false)
+
+ act(() => {
+ markUnreadButton?.click()
+ })
+ expect(onMarkThreadUnread).toHaveBeenCalledWith(mockThread)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-thread-list-pane.tsx b/src/renderer/src/components/activity/activity-thread-list-pane.tsx
index 4411d385e0b..9c2beee6e0c 100644
--- a/src/renderer/src/components/activity/activity-thread-list-pane.tsx
+++ b/src/renderer/src/components/activity/activity-thread-list-pane.tsx
@@ -1,19 +1,29 @@
-import React from 'react'
-import { BellDot, Search } from 'lucide-react'
-import { Input } from '@/components/ui/input'
+import React, { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
import {
- Select,
- SelectContent,
- SelectItem,
- SelectTrigger,
- SelectValue
-} from '@/components/ui/select'
-import { Toggle } from '@/components/ui/toggle'
-import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+ defaultRangeExtractor,
+ measureElement as measureVirtualElementSize,
+ observeElementRect,
+ useVirtualizer,
+ type Range
+} from '@tanstack/react-virtual'
import { cn } from '@/lib/utils'
import { translate } from '@/i18n/i18n'
-import { ActivityStatusGroupHeader, ActivityThreadOptionsMenu } from './activity-thread-controls'
-import { ActivityThreadRow } from './activity-thread-row'
+import { ActivityThreadListToolbar } from './activity-thread-list-toolbar'
+import {
+ getActiveStickyHeaderIndex,
+ getActiveStickyHeaderIndexForScroll,
+ getPreviousStickyHeaderIndex
+} from '../sidebar/worktree-list/viewport/virtual-rows'
+import { ActivityThreadVirtualRow } from './activity-thread-virtual-row'
+import { ActivityThreadListResizeHandle } from './activity-thread-list-resize-handle'
+import {
+ buildActivityVirtualItems,
+ estimateActivityVirtualItemSize,
+ findActivityThreadItemIndex,
+ getActivityHeaderItemIndexes,
+ getActivityVirtualItemKey
+} from './activity-thread-virtual-items'
+import { ActivityThreadCollapseContext } from './activity-thread-collapse-context'
import type {
ActivityGroupBy,
ActivityThreadGroup,
@@ -21,6 +31,16 @@ import type {
ThreadReadFilter
} from './activity-thread-types'
+const ZERO_RECT_FALLBACK_VIEWPORT = { width: 320, height: 600 }
+const observeActivityListRect: typeof observeElementRect = (instance, cb) =>
+ observeElementRect(instance, (rect) => {
+ cb(rect.height > 0 ? rect : ZERO_RECT_FALLBACK_VIEWPORT)
+ })
+
+// A saved offset the content cannot contain yet is restored once it can; past
+// this window it is stale (the list shrank) and restoring would yank the viewport.
+const DEFERRED_SCROLL_RESTORE_WINDOW_MS = 3000
+
export function ActivityThreadListPane({
threadListRef,
threadListWidth,
@@ -32,21 +52,34 @@ export function ActivityThreadListPane({
readFilter,
onReadFilterChange,
compactMode,
+ showChildAgents,
hasUnreadThreads,
onCompactModeChange,
+ onShowChildAgentsChange,
onMarkAllThreadsRead,
+ hasCompletedThreads,
+ onClearCompleted,
visibleThreadGroups,
visibleThreadCount,
selectedPaneKey,
onSelectThread,
onJumpToWorkspace,
+ onMarkThreadRead,
onMarkThreadUnread,
canJumpToWorkspace,
+ allowMarkUnreadWhenSelected = false,
+ showJumpAction = true,
isThreadListResizing,
- onResizeStart
+ onResizeStart,
+ showFilterControls = true,
+ showOptionsMenu = true,
+ scopeFilterRow,
+ collapsedGroupKeys,
+ onToggleGroupCollapse,
+ scrollTopRef
}: {
- threadListRef: React.RefObject
- threadListWidth: number
+ threadListRef?: React.RefObject
+ threadListWidth?: number
activityFilterInputRef: React.RefObject
query: string
onQueryChange: (query: string) => void
@@ -55,163 +88,308 @@ export function ActivityThreadListPane({
readFilter: ThreadReadFilter
onReadFilterChange: (readFilter: ThreadReadFilter) => void
compactMode: boolean
+ showChildAgents?: boolean
hasUnreadThreads: boolean
onCompactModeChange: (compactMode: boolean) => void
- onMarkAllThreadsRead: () => void
+ onShowChildAgentsChange?: (showChildAgents: boolean) => void
+ onMarkAllThreadsRead?: () => void
+ hasCompletedThreads?: boolean
+ onClearCompleted?: () => void
visibleThreadGroups: ActivityThreadGroup[]
visibleThreadCount: number
selectedPaneKey: string | null
onSelectThread: (thread: AgentPaneThread) => void
onJumpToWorkspace: (thread: AgentPaneThread) => void
+ onMarkThreadRead: (thread: AgentPaneThread) => void
onMarkThreadUnread: (thread: AgentPaneThread) => void
canJumpToWorkspace: (thread: AgentPaneThread) => boolean
- isThreadListResizing: boolean
- onResizeStart: React.MouseEventHandler
+ allowMarkUnreadWhenSelected?: boolean
+ showJumpAction?: boolean
+ isThreadListResizing?: boolean
+ onResizeStart?: React.MouseEventHandler
+ showFilterControls?: boolean
+ showOptionsMenu?: boolean
+ /** Rendered between the toolbar and the list; carries the active-scope chips row. */
+ scopeFilterRow?: React.ReactNode
+ collapsedGroupKeys?: ReadonlySet
+ onToggleGroupCollapse?: (groupKey: string) => void
+ /** Optional view-local scroll memory; updated without triggering React renders. */
+ scrollTopRef?: React.MutableRefObject
}): React.JSX.Element {
+ const [internalCollapsedGroupKeys, setInternalCollapsedGroupKeys] = useState>(
+ () => new Set()
+ )
+ // Precedence: explicit props, then a caller-owned context (hosts that unmount
+ // the pane on body switches), then pane-local state.
+ const contextCollapse = useContext(ActivityThreadCollapseContext)
+ const isControlled = collapsedGroupKeys !== undefined && onToggleGroupCollapse !== undefined
+ const effectiveCollapsedGroupKeys = isControlled
+ ? collapsedGroupKeys
+ : (contextCollapse?.collapsedGroupKeys ?? internalCollapsedGroupKeys)
+ const handleToggleGroup = isControlled
+ ? onToggleGroupCollapse
+ : (contextCollapse?.onToggleGroupCollapse ??
+ ((groupKey: string) => {
+ setInternalCollapsedGroupKeys((prev) => {
+ const next = new Set(prev)
+ if (next.has(groupKey)) {
+ next.delete(groupKey)
+ } else {
+ next.add(groupKey)
+ }
+ return next
+ })
+ }))
+
+ const scrollContainerRef = useRef(null)
+ const hasRestoredScrollRef = useRef(false)
+ const handleScroll = useCallback(
+ (event: React.UIEvent) => {
+ if (!scrollTopRef) {
+ return
+ }
+ const scrollTop = event.currentTarget.scrollTop
+ // A clamp-to-0 fired before the deferred restore must not wipe the saved offset.
+ if (!hasRestoredScrollRef.current) {
+ if (scrollTop === 0) {
+ return
+ }
+ hasRestoredScrollRef.current = true
+ }
+ scrollTopRef.current = scrollTop
+ },
+ [scrollTopRef]
+ )
+ const virtualItems = useMemo(
+ () =>
+ buildActivityVirtualItems({
+ groups: visibleThreadGroups,
+ groupBy,
+ collapsedGroupKeys: effectiveCollapsedGroupKeys
+ }),
+ [visibleThreadGroups, groupBy, effectiveCollapsedGroupKeys]
+ )
+ const headerItemIndexes = useMemo(
+ () => getActivityHeaderItemIndexes(virtualItems),
+ [virtualItems]
+ )
+ const selectedItemIndex = useMemo(
+ () => findActivityThreadItemIndex(virtualItems, selectedPaneKey),
+ [virtualItems, selectedPaneKey]
+ )
+
+ // Why keyed on virtualItems: getItemKey identity is a measurement-memo input in tanstack
+ // virtual. A per-render closure recomputes every row on unrelated re-renders; a fully stable
+ // one would miss same-count reorders. Changing exactly with the items is the correct middle.
+ const getItemKey = useCallback(
+ (index: number) => {
+ const item = virtualItems[index]
+ return item ? getActivityVirtualItemKey(item) : `__stale_${index}`
+ },
+ [virtualItems]
+ )
+ const virtualizer = useVirtualizer({
+ count: virtualItems.length,
+ getScrollElement: () => scrollContainerRef.current,
+ estimateSize: (index) => estimateActivityVirtualItemSize(virtualItems[index], compactMode),
+ getItemKey,
+ measureElement: (element, entry, instance) => {
+ const measured = measureVirtualElementSize(element, entry, instance)
+ if (measured > 0) {
+ return measured
+ }
+ const index = Number.parseInt(element.getAttribute('data-index') ?? '', 10)
+ return estimateActivityVirtualItemSize(
+ Number.isNaN(index) ? undefined : virtualItems[index],
+ compactMode
+ )
+ },
+ rangeExtractor: useCallback(
+ (range: Range) => {
+ const activeStickyIndex =
+ groupBy !== 'none'
+ ? getActiveStickyHeaderIndex(headerItemIndexes, range.startIndex)
+ : null
+ const previousStickyIndex =
+ activeStickyIndex !== null
+ ? getPreviousStickyHeaderIndex(headerItemIndexes, activeStickyIndex)
+ : null
+ const indexSet = new Set(defaultRangeExtractor(range))
+ if (activeStickyIndex !== null) {
+ indexSet.add(activeStickyIndex)
+ }
+ if (previousStickyIndex !== null) {
+ indexSet.add(previousStickyIndex)
+ }
+ if (selectedItemIndex !== null && selectedItemIndex >= 0) {
+ indexSet.add(selectedItemIndex)
+ }
+ return Array.from(indexSet).sort((a, b) => a - b)
+ },
+ [groupBy, headerItemIndexes, selectedItemIndex]
+ ),
+ overscan: 8,
+ observeElementRect: observeActivityListRect,
+ useFlushSync: false
+ })
+
+ // Row heights differ between densities; drop stale measurements on toggle (not on mount).
+ const measuredCompactModeRef = useRef(compactMode)
+ useEffect(() => {
+ if (measuredCompactModeRef.current === compactMode) {
+ return
+ }
+ measuredCompactModeRef.current = compactMode
+ virtualizer.measure()
+ }, [virtualizer, compactMode])
+
+ // Restore only once the (estimated) content can contain the saved offset, so a
+ // pre-hydration mount doesn't clamp the restore to 0.
+ const totalSize = virtualizer.getTotalSize()
+ const restoreArmedAtRef = useRef(null)
+ useEffect(() => {
+ if (!scrollTopRef || hasRestoredScrollRef.current) {
+ return
+ }
+ if (restoreArmedAtRef.current === null) {
+ restoreArmedAtRef.current = Date.now()
+ } else if (Date.now() - restoreArmedAtRef.current > DEFERRED_SCROLL_RESTORE_WINDOW_MS) {
+ // The list stayed too small for the saved offset (it shrank); firing the
+ // restore on some later growth would yank the viewport out from the user.
+ hasRestoredScrollRef.current = true
+ scrollTopRef.current = 0
+ return
+ }
+ const scrollContainer = scrollContainerRef.current
+ if (!scrollContainer) {
+ return
+ }
+ // Against the max offset, not the content height: a viewport taller than the
+ // remaining content clamps the assignment to 0 and burns the one restore.
+ const maxScrollTop = Math.max(0, totalSize - scrollContainer.clientHeight)
+ if (scrollTopRef.current > maxScrollTop) {
+ return
+ }
+ scrollContainer.scrollTop = scrollTopRef.current
+ hasRestoredScrollRef.current = true
+ }, [scrollTopRef, totalSize])
+
+ const scrollOffset = virtualizer.scrollOffset ?? 0
+ const activeStickyHeaderIndex =
+ groupBy !== 'none'
+ ? getActiveStickyHeaderIndexForScroll({
+ rangeStartIndex: virtualizer.range?.startIndex ?? 0,
+ scrollOffset,
+ stickyHeaderIndexes: headerItemIndexes,
+ virtualItems: virtualizer.getVirtualItems()
+ })
+ : null
+
+ const resizable = onResizeStart !== undefined
return (
{
+ if (event.key === 'Enter' || event.key === ' ') {
+ event.preventDefault()
+ onToggle?.()
+ }
+ }
+ : undefined
+ }
+ className={cn(
+ 'group flex h-7 select-none items-center gap-1.5 rounded-md px-1.5 py-1 text-muted-foreground transition-colors',
+ isInteractive && 'cursor-pointer hover:bg-accent/60 hover:text-foreground',
+ className
+ )}
+ >
+
diff --git a/src/renderer/src/components/activity/activity-thread-grouping.search-cache.test.ts b/src/renderer/src/components/activity/activity-thread-grouping.search-cache.test.ts
new file mode 100644
index 00000000000..4c5b003eac4
--- /dev/null
+++ b/src/renderer/src/components/activity/activity-thread-grouping.search-cache.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import {
+ activityThreadMatchesSearchQuery,
+ getThreadSearchTextComputeCount
+} from './activity-thread-grouping'
+import type { AgentPaneThread } from './activity-thread-types'
+import { makeTab, makeWorktree } from './ActivityPrototypePage-test-fixtures'
+
+function makeThread(paneKey: string, paneTitle: string): AgentPaneThread {
+ return {
+ paneKey,
+ tab: makeTab(),
+ worktree: makeWorktree(),
+ repo: null,
+ currentAgentState: null,
+ currentAgentEntry: null,
+ latestEvent: null,
+ latestTimestamp: 1_000,
+ agentType: 'claude',
+ unread: false,
+ paneTitle,
+ responsePreview: 'x'.repeat(2_000),
+ events: []
+ }
+}
+
+describe('activity thread search text cache', () => {
+ it('builds a thread searchable text once per thread identity across keystrokes', () => {
+ const thread = makeThread('tab-1:leaf-1', 'Refactor billing pipeline')
+ const before = getThreadSearchTextComputeCount()
+ // Simulate typing a query letter by letter against the same thread objects.
+ for (const searchQuery of ['r', 're', 'ref', 'refa', 'refac']) {
+ expect(activityThreadMatchesSearchQuery({ thread, searchQuery })).toBe(true)
+ }
+ expect(getThreadSearchTextComputeCount() - before).toBe(1)
+ })
+
+ it('recomputes when thread data changes (new thread identity)', () => {
+ const before = getThreadSearchTextComputeCount()
+ const first = makeThread('tab-1:leaf-1', 'First title')
+ const rebuilt = makeThread('tab-1:leaf-1', 'Second title')
+ expect(activityThreadMatchesSearchQuery({ thread: first, searchQuery: 'first' })).toBe(true)
+ expect(activityThreadMatchesSearchQuery({ thread: rebuilt, searchQuery: 'second' })).toBe(true)
+ expect(getThreadSearchTextComputeCount() - before).toBe(2)
+ })
+
+ it('keeps match semantics: state labels, workspace, and previews still match', () => {
+ const thread = makeThread('tab-1:leaf-1', 'My task')
+ expect(activityThreadMatchesSearchQuery({ thread, searchQuery: 'feature' })).toBe(true)
+ expect(activityThreadMatchesSearchQuery({ thread, searchQuery: 'zzz-no-match' })).toBe(false)
+ expect(activityThreadMatchesSearchQuery({ thread, searchQuery: '' })).toBe(true)
+ })
+})
diff --git a/src/renderer/src/components/activity/activity-thread-grouping.ts b/src/renderer/src/components/activity/activity-thread-grouping.ts
index 1744c0b84f6..0730aa68b5d 100644
--- a/src/renderer/src/components/activity/activity-thread-grouping.ts
+++ b/src/renderer/src/components/activity/activity-thread-grouping.ts
@@ -18,19 +18,23 @@ import type {
AgentPaneThread
} from './activity-thread-types'
+// Attention-needing groups first (interrupted included: it's stopped and awaiting the user) so they're never buried under Working/Done.
const ACTIVITY_STATUS_GROUP_ORDER: ActivityStatusGroupId[] = [
+ 'waiting',
+ 'blocked',
+ 'interrupted',
'working',
'monitoring',
- 'blocked',
- 'waiting',
- 'done',
- 'interrupted'
+ 'done'
]
export function getActivityThreadGroup(
thread: AgentPaneThread,
groupBy: ActivityGroupBy
): { key: string; label: string } {
+ if (groupBy === 'none') {
+ return { key: 'all', label: '' }
+ }
if (groupBy === 'status') {
const state = threadAgentState(thread)
if (!thread.currentAgentState && state === 'done' && thread.latestEvent?.entry.interrupted) {
@@ -59,6 +63,9 @@ export function buildActivityThreadGroups(
threads: AgentPaneThread[],
groupBy: ActivityGroupBy
): ActivityThreadGroup[] {
+ if (groupBy === 'none') {
+ return threads.length > 0 ? [{ key: 'all', label: '', threads }] : []
+ }
const groups: ActivityThreadGroup[] = []
const groupIndexByKey = new Map
+
+
+
+
+
+
+
+
+
+
+
+ {taskTitle}
+
+
+ {thread.responsePreview ? (
+
+
+ ) : null}
+
+ {repo ? (
+
+
+ {branchIdentityDisplay ? (
+
+
+ ) : null}
+
+ {workspaceTitle}
+
+
+
+ ) : null}
+
+
+ {parsedHost?.kind === 'runtime' ? (
+
+
+ {worktree.path ? (
+
+
+ {worktree.path}
+
+
+
+
+ ) : null}
+
+ {children}
+
+ ),
+ HoverCardTrigger: ({ children }: { children: ReactNode }) => <>{children}
+}))
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true
+
+function createTestThread(overrides: PartialHover Target
+ Hover Target
+
+ {secondary.hoverLinearIssue.title}
+
+ {((secondary.hoverLinearIssue.labels &&
+ secondary.hoverLinearIssue.labels.length > 0) ||
+ secondary.hoverLinearIssue.stateName) && (
+
+ {secondary.hoverLinearIssue.stateName && (
+
+ {label}
+
+ ))}
+
+ )}
+
+ {secondary.hoverJiraIssue.title}
+
+