From 3aec8991bf4345fd0ab0b2924277c9fb5bb109cc Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 20:46:19 -0800 Subject: [PATCH 1/6] fix(sleep): sleep keeps every tab in place, same order and active tab; pages reload when shown after wake (NEW-01) --- .../orca-cloud/OrcaCloudWorkspaceSurface.tsx | 2 - .../project-move-pause-follower.test.ts | 13 +++- .../sleep/workspace-sleep-follower.ts | 15 ++-- .../desktop-sleep-reopen.test.ts | 74 ------------------- .../desktop-sleep-reopen.ts | 48 ------------ .../open-cloud-remote-desktop.tsx | 17 ----- 6 files changed, 20 insertions(+), 149 deletions(-) delete mode 100644 src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts delete mode 100644 src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts diff --git a/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx b/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx index f2223d64523..7b3116d044c 100644 --- a/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx +++ b/src/renderer/src/components/orca-cloud/OrcaCloudWorkspaceSurface.tsx @@ -1,4 +1,3 @@ -import { useReopenRemoteDesktopAfterWake } from '@/lib/cloud-remote-desktop/desktop-sleep-reopen' import React, { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react' import { toast } from 'sonner' import { useAppStore } from '@/store' @@ -224,7 +223,6 @@ function useInertSiblings(cover: React.RefObject, active: bo function CloudSurface({ workspaceId }: { workspaceId: string }): React.JSX.Element | null { const t = useTranslate() const view = useCloudWorkspaceView(workspaceId) - useReopenRemoteDesktopAfterWake(workspaceId, view.state === 'running') const name = useAppStore((state) => findWorktreeById(state, workspaceId)?.displayName ?? null) // Ready means the server answers; the pill stays ("Connecting…") until the pane in front has // re-attached and can take keys. diff --git a/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts b/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts index 8a5776cdf3a..f42f7b6c13d 100644 --- a/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts +++ b/src/renderer/src/components/sidebar/project-move-pause-follower.test.ts @@ -11,6 +11,8 @@ const mocks = vi.hoisted(() => { activeWorktreeId: null, setActiveWorktree: vi.fn(), shutdownWorktreeBrowsers: vi.fn(), + browserTabsByWorktree: {}, + browserPagesByWorkspace: {}, shutdownWorktreeTerminals: vi.fn(), tabsByWorktree, ptyIdsByTabId, @@ -18,9 +20,14 @@ const mocks = vi.hoisted(() => { detectedWorktreesByRepo: {} }, persist: vi.fn(async () => {}), - payload: vi.fn(() => ({})) + payload: vi.fn(() => ({})), + evictGuests: vi.fn() } }) +vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ + destroyWorktreeBrowserGuests: (_tabs: unknown, _pages: unknown, worktreeId: string) => + mocks.evictGuests(worktreeId) +})) vi.mock('@/store', () => ({ useAppStore: { getState: () => mocks.state, subscribe: () => () => {} } })) @@ -203,7 +210,9 @@ describe('project move renderer completion', () => { records: [] }) await f.persist() - expect(mocks.state.shutdownWorktreeBrowsers).toHaveBeenCalledWith('wt') + // Sleep keeps the tabs (NEW-01); only their pages are dropped. + expect(mocks.state.shutdownWorktreeBrowsers).not.toHaveBeenCalled() + expect(mocks.evictGuests).toHaveBeenCalledWith('wt') expect(f.responses.at(-1)).toMatchObject({ phase: 'error', error: 'project_move_pause_sleep_superseded' diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts index ba14d165b55..bb771acf502 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts @@ -1,5 +1,5 @@ import { useAppStore } from '@/store' -import { noteRemoteDesktopBeforeSleep } from '@/lib/cloud-remote-desktop/desktop-sleep-reopen' +import { destroyWorktreeBrowserGuests } from '@/store/slices/browser/cleanup/browser-webview-cleanup' import { captureWorkspaceSelection, restoreWorkspaceSelection, @@ -56,10 +56,6 @@ export function followWorkspaceSleep( const state = useAppStore.getState() const wasActive = state.activeWorktreeId === worktreeId const selectionBeforeSleep = wasActive ? captureWorkspaceSelection(state) : null - if (!options.keepBrowserTabs) { - // Before the selection clears: whether the desktop tab was in front decides how it comes back. - noteRemoteDesktopBeforeSleep(worktreeId) - } // Why first: clearing the active workspace unmounts its panes, whose exits must not stamp activity. markWorktreeSleepIntent(worktreeId) if (wasActive) { @@ -68,7 +64,14 @@ export function followWorkspaceSleep( restoreSidebarPosition() } if (!options.keepBrowserTabs) { - state.shutdownWorktreeBrowsers(worktreeId) + // Sleep never changes the tab layout (NEW-01): the tabs, their order and the active one stay; + // only their pages are dropped to free memory, and each reloads in place when shown after + // the wake. A remote desktop tab reconnects itself the same way (its chrome). + destroyWorktreeBrowserGuests( + state.browserTabsByWorktree, + state.browserPagesByWorkspace, + worktreeId + ) } let settle!: (stop: HostTerminalStop) => void const hostStop = new Promise((resolve) => (settle = resolve)) diff --git a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts b/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts deleted file mode 100644 index aae8d67601d..00000000000 --- a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.test.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' - -const DESKTOP = 'http://localhost:6080/vnc.html?autoconnect=0&reconnect=0&resize=remote' -let state: Record = {} -const reopen = vi.fn(async () => {}) - -vi.mock('@/store', () => ({ useAppStore: { getState: () => state } })) -vi.mock('@/lib/workspace/ownership/workspace-runtime-environment', () => ({ - selectWorkspaceRuntimeEnvironmentId: () => 'env-1', - useWorkspaceRuntimeEnvironmentId: () => 'env-1' -})) -vi.mock('./open-cloud-remote-desktop', () => ({ - reopenCloudRemoteDesktopQuietly: reopen, - openCloudRemoteDesktop: vi.fn() -})) -vi.mock('react', () => ({ - useEffect: (fn: () => void) => fn(), - useMemo: (fn: () => unknown) => fn() -})) - -const { - hasRemoteDesktopToReopen, - noteRemoteDesktopBeforeSleep, - resetRemoteDesktopSleepReopenForTest, - useReopenRemoteDesktopAfterWake -} = await import('./desktop-sleep-reopen') - -describe('remote desktop across sleep', () => { - beforeEach(() => { - resetRemoteDesktopSleepReopenForTest() - reopen.mockClear() - }) - - it('remembers a desktop tab that sleep closes and reopens it once the workspace runs', () => { - state = { - activeWorktreeId: 'w1', - activeTabType: 'browser', - activeBrowserTabId: 'tab-d', - browserTabsByWorktree: { - w1: [ - { id: 'tab-b', url: 'https://example.com' }, - { id: 'tab-d', url: DESKTOP } - ] - } - } - noteRemoteDesktopBeforeSleep('w1') - expect(hasRemoteDesktopToReopen('w1')).toBe(true) - useReopenRemoteDesktopAfterWake('w1', false) - expect(reopen).not.toHaveBeenCalled() - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledWith('w1', 'env-1', true) - // Once only. - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledTimes(1) - }) - - it('reopens a desktop that was behind another tab without bringing it to the front', () => { - state = { - activeWorktreeId: 'w1', - activeTabType: 'terminal', - activeBrowserTabId: null, - browserTabsByWorktree: { w1: [{ id: 'tab-d', url: DESKTOP }] } - } - noteRemoteDesktopBeforeSleep('w1') - useReopenRemoteDesktopAfterWake('w1', true) - expect(reopen).toHaveBeenCalledWith('w1', 'env-1', false) - }) - - it('does nothing for a workspace without a desktop tab', () => { - state = { browserTabsByWorktree: { w1: [{ id: 'tab-b', url: 'http://localhost:3000/' }] } } - noteRemoteDesktopBeforeSleep('w1') - expect(hasRemoteDesktopToReopen('w1')).toBe(false) - }) -}) diff --git a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts b/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts deleted file mode 100644 index 266971a9600..00000000000 --- a/src/renderer/src/lib/cloud-remote-desktop/desktop-sleep-reopen.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { useEffect } from 'react' -import { useAppStore } from '@/store' -import { selectWorkspaceRuntimeEnvironmentId } from '@/lib/workspace/ownership/workspace-runtime-environment' -import { selectRemoteDesktopTabId } from './remote-desktop-tab' -import { reopenCloudRemoteDesktopQuietly } from './open-cloud-remote-desktop' - -// Sleep closes a workspace's browser tabs (workspace-sleep-follower.ts), and the desktop's processes -// stop with the sandbox anyway. A remote desktop tab is remembered here and comes back on its own -// once the workspace is awake, in front again if it was in front. -const sleptWithDesktop = new Map() - -/** Call before sleep tears down the workspace's browser tabs. */ -export function noteRemoteDesktopBeforeSleep(worktreeId: string): void { - const state = useAppStore.getState() - const tabId = selectRemoteDesktopTabId(state, worktreeId) - if (!tabId) { - return - } - sleptWithDesktop.set(worktreeId, { - wasInFront: - state.activeWorktreeId === worktreeId && - state.activeTabType === 'browser' && - state.activeBrowserTabId === tabId - }) -} - -/** Reopens it when the workspace is running again (mounted for the workspace on screen). */ -export function useReopenRemoteDesktopAfterWake(worktreeId: string, running: boolean): void { - useEffect(() => { - const entry = running ? sleptWithDesktop.get(worktreeId) : undefined - if (!entry) { - return - } - sleptWithDesktop.delete(worktreeId) - const environmentId = selectWorkspaceRuntimeEnvironmentId(useAppStore.getState(), worktreeId) - if (environmentId) { - void reopenCloudRemoteDesktopQuietly(worktreeId, environmentId, entry.wasInFront) - } - }, [running, worktreeId]) -} - -export function hasRemoteDesktopToReopen(worktreeId: string): boolean { - return sleptWithDesktop.has(worktreeId) -} - -export function resetRemoteDesktopSleepReopenForTest(): void { - sleptWithDesktop.clear() -} diff --git a/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx b/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx index 3a7d9d69887..61a460b0adc 100644 --- a/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx +++ b/src/renderer/src/lib/cloud-remote-desktop/open-cloud-remote-desktop.tsx @@ -139,23 +139,6 @@ function showDesktopTab( }) } -/** - * Reopens a desktop tab that sleep closed, once the workspace is awake again: no toasts (the tab's - * own state says how it goes) and it only comes to the front if it was in front when it slept. - */ -export function reopenCloudRemoteDesktopQuietly( - worktreeId: string, - environmentId: string, - activate: boolean -): Promise { - return exclusive(worktreeId, async () => { - const result = await requestCloudRemoteDesktop(environmentId) - if (result.ok) { - showDesktopTab(worktreeId, environmentId, result.url, activate) - } - }) -} - /** One open or wake at a time per workspace: a second click while one runs does nothing. */ async function exclusive(worktreeId: string, work: () => Promise): Promise { if (typeof window.api?.ephemeralVm?.openCloudRemoteDesktop !== 'function') { From 09f7f1e245e3ade44efc6771ae458c6e0ffbb008 Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 20:53:05 -0800 Subject: [PATCH 2/6] fix(sleep): browser tabs sleep in place (marked, pages dropped) instead of closing; opening the workspace wakes them (NEW-01) --- .../workspace-lineage-menu-actions.ts | 4 +- .../sleep/browser-tab-sleep.test.ts | 94 +++++++++++++++++++ .../sleep/browser-tab-sleep.ts | 87 +++++++++++++++++ .../sleep/workspace-sleep-follower.ts | 13 +-- .../visible-worktree-activity-inputs.ts | 8 +- .../mobile-terminal-close-ipc-bridge.ts | 3 + .../workspace-activity-shadow.ts | 2 +- .../src/lib/worktree-activity-state.ts | 5 +- src/renderer/src/lib/worktree-status.ts | 11 ++- src/shared/browser-workspace-types.ts | 5 + .../workspace-layout-disk-fields.ts | 4 +- 11 files changed, 216 insertions(+), 20 deletions(-) create mode 100644 src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts create mode 100644 src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts diff --git a/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts b/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts index 645697c35c3..ae45592fd84 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts @@ -11,7 +11,7 @@ import { getWorkspaceDeleteLineage } from '../deletion/workspace-delete-lineage' type WorkspaceActivityMaps = { tabsByWorktree: Record ptyIdsByTabId: Record - browserTabsByWorktree: Record + browserTabsByWorktree: Record unifiedTabsByWorktree: Record agentStatusByPaneKey: Record structuredChatSleptAtByPaneKey: StructuredChatSleptAtByPaneKey @@ -30,7 +30,7 @@ export function hasSleepableWorkspaceActivity( const tabs = activity.tabsByWorktree[worktreeId] ?? [] return ( tabs.some((tab) => tabHasLivePty(activity.ptyIdsByTabId, tab.id)) || - (activity.browserTabsByWorktree[worktreeId] ?? []).length > 0 || + (activity.browserTabsByWorktree[worktreeId] ?? []).some((tab) => !tab.sleptAt) || // An idle-ended chat still needs Sleep to hide it, even when its legacy tab has no host stamp. (activity.unifiedTabsByWorktree[worktreeId] ?? []).some( (tab) => diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts new file mode 100644 index 00000000000..5d46053752d --- /dev/null +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts @@ -0,0 +1,94 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { BrowserWorkspace } from '../../../../../../shared/browser-workspace-types' + +type State = { + activeWorktreeId: string | null + browserTabsByWorktree: Record + browserPagesByWorkspace: Record + activeBrowserTabIdByWorktree: Record +} + +const mocks = vi.hoisted(() => { + const listeners = new Set<(state: unknown) => void>() + const store = { + state: {} as Record, + getState: () => store.state, + setState: (change: (state: Record) => Record) => { + store.state = { ...store.state, ...change(store.state) } + for (const listener of listeners) { + listener(store.state) + } + }, + subscribe: (listener: (state: unknown) => void) => { + listeners.add(listener) + return () => listeners.delete(listener) + } + } + return { store, evicted: [] as string[] } +}) +vi.mock('@/store', () => ({ useAppStore: mocks.store })) +vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ + destroyWorktreeBrowserGuests: (_tabs: unknown, _pages: unknown, worktreeId: string) => + mocks.evicted.push(worktreeId) +})) + +const { sleepWorktreeBrowserTabs, installBrowserTabWakeOnOpen } = await import( + './browser-tab-sleep' +) +const { isInactiveWorkspace } = await import('@/lib/worktree-activity-state') + +const tab = (id: string): BrowserWorkspace => ({ + id, + worktreeId: 'wt', + url: `http://localhost:3000/${id}`, + title: id, + loading: false, + faviconUrl: null, + canGoBack: false, + canGoForward: false, + loadError: null, + createdAt: 1 +}) + +const state = (): State => mocks.store.getState() as unknown as State + +beforeEach(() => { + mocks.evicted.length = 0 + mocks.store.state = { + activeWorktreeId: null, + browserTabsByWorktree: { wt: [tab('a'), tab('b'), tab('c')] }, + browserPagesByWorkspace: {}, + activeBrowserTabIdByWorktree: { wt: 'b' } + } +}) + +describe('sleep keeps browser tabs in place (NEW-01)', () => { + it('keeps every tab, in order, with the same active tab; drops only their pages', () => { + sleepWorktreeBrowserTabs('wt', 42) + expect(mocks.evicted).toEqual(['wt']) + expect(state().browserTabsByWorktree.wt.map((t) => t.id)).toEqual(['a', 'b', 'c']) + expect(state().browserTabsByWorktree.wt.every((t) => t.sleptAt === 42)).toBe(true) + expect(state().activeBrowserTabIdByWorktree.wt).toBe('b') + }) + + it('asleep tabs are not activity, so the workspace still reads as asleep', () => { + const inactive = (): boolean => + isInactiveWorkspace('wt', {}, {}, state().browserTabsByWorktree, new Set()) + expect(inactive()).toBe(false) + sleepWorktreeBrowserTabs('wt', 42) + expect(inactive()).toBe(true) + }) + + it('opening the workspace again wakes its tabs, still in the same order', () => { + const stop = installBrowserTabWakeOnOpen() + sleepWorktreeBrowserTabs('wt', 42) + mocks.store.setState(() => ({ activeWorktreeId: 'wt' })) + expect(state().browserTabsByWorktree.wt.map((t) => [t.id, t.sleptAt])).toEqual([ + ['a', undefined], + ['b', undefined], + ['c', undefined] + ]) + expect(state().activeBrowserTabIdByWorktree.wt).toBe('b') + stop() + }) +}) diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts new file mode 100644 index 00000000000..22c63636083 --- /dev/null +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts @@ -0,0 +1,87 @@ +// Sleep never changes a workspace's tab layout (NEW-01). Its browser tabs stay where they are, in +// the same order with the same active tab; only their pages are dropped to free memory, and each +// tab is marked asleep so it no longer counts as activity (an asleep workspace still reads as +// asleep and hides with "Hide sleeping"). Opening the workspace again wakes the tabs: each page +// reloads in place when it is shown. A remote desktop tab's own chrome reconnects it after a wake. +import { useAppStore } from '@/store' +import { destroyWorktreeBrowserGuests } from '@/store/slices/browser/cleanup/browser-webview-cleanup' +import type { BrowserWorkspace } from '../../../../../../shared/browser-workspace-types' + +/** Awake tabs are activity; a tab Sleep put to rest is not, until the workspace is opened again. */ +export function isAwakeBrowserTab(tab: { sleptAt?: number | null }): boolean { + return !tab.sleptAt +} + +export function hasAwakeBrowserTab( + tabs: readonly { sleptAt?: number | null }[] | null | undefined +): boolean { + return (tabs ?? []).some(isAwakeBrowserTab) +} + +function stamp( + tabs: readonly BrowserWorkspace[], + sleptAt: number | undefined +): BrowserWorkspace[] | null { + let changed = false + const next = tabs.map((tab) => { + if ((tab.sleptAt ?? undefined) === sleptAt) { + return tab + } + changed = true + const copy: BrowserWorkspace = { ...tab } + if (sleptAt === undefined) { + delete copy.sleptAt + } else { + copy.sleptAt = sleptAt + } + return copy + }) + return changed ? next : null +} + +/** Sleep: drop the pages, keep the tabs, mark them asleep. */ +export function sleepWorktreeBrowserTabs(worktreeId: string, now: number = Date.now()): void { + const state = useAppStore.getState() + destroyWorktreeBrowserGuests( + state.browserTabsByWorktree, + state.browserPagesByWorkspace, + worktreeId + ) + const next = stamp(state.browserTabsByWorktree[worktreeId] ?? [], now) + if (next) { + useAppStore.setState((s) => ({ + browserTabsByWorktree: { ...s.browserTabsByWorktree, [worktreeId]: next } + })) + } +} + +/** The workspace is open again: its tabs count as activity once more (pages reload when shown). */ +export function wakeWorktreeBrowserTabs(worktreeId: string): void { + const tabs = useAppStore.getState().browserTabsByWorktree[worktreeId] + if (!tabs || !tabs.some((tab) => tab.sleptAt)) { + return + } + const next = stamp(tabs, undefined) + if (next) { + useAppStore.setState((s) => ({ + browserTabsByWorktree: { ...s.browserTabsByWorktree, [worktreeId]: next } + })) + } +} + +/** Wakes a workspace's asleep tabs whenever it becomes the active one (also after an app restart). */ +export function installBrowserTabWakeOnOpen(): () => void { + let previous = useAppStore.getState().activeWorktreeId + if (previous) { + wakeWorktreeBrowserTabs(previous) + } + return useAppStore.subscribe((state) => { + if (state.activeWorktreeId === previous) { + return + } + previous = state.activeWorktreeId + if (previous) { + wakeWorktreeBrowserTabs(previous) + } + }) +} diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts index bb771acf502..8dabfd1cb24 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/workspace-sleep-follower.ts @@ -1,5 +1,5 @@ import { useAppStore } from '@/store' -import { destroyWorktreeBrowserGuests } from '@/store/slices/browser/cleanup/browser-webview-cleanup' +import { sleepWorktreeBrowserTabs, wakeWorktreeBrowserTabs } from './browser-tab-sleep' import { captureWorkspaceSelection, restoreWorkspaceSelection, @@ -65,13 +65,8 @@ export function followWorkspaceSleep( } if (!options.keepBrowserTabs) { // Sleep never changes the tab layout (NEW-01): the tabs, their order and the active one stay; - // only their pages are dropped to free memory, and each reloads in place when shown after - // the wake. A remote desktop tab reconnects itself the same way (its chrome). - destroyWorktreeBrowserGuests( - state.browserTabsByWorktree, - state.browserPagesByWorkspace, - worktreeId - ) + // only their pages are dropped, and each reloads in place when shown after the wake. + sleepWorktreeBrowserTabs(worktreeId) } let settle!: (stop: HostTerminalStop) => void const hostStop = new Promise((resolve) => (settle = resolve)) @@ -108,6 +103,8 @@ export function followWorkspaceSleep( // A failed sleep leaves the workspace awake and retryable; one the user reopened is theirs. if (!notice.slept || state.activeWorktreeId === worktreeId) { clearWorktreeSleepIntent(worktreeId) + // Still awake: its tabs count as activity again. + wakeWorktreeBrowserTabs(worktreeId) } if (!notice.slept && entry?.selectionBeforeSleep && state.activeWorktreeId === null) { restoreWorkspaceSelection(state, entry.selectionBeforeSleep) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts index df576d451e9..33687dbae47 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts @@ -7,7 +7,7 @@ import { createWorktreeTabBucketProjection } from '@/lib/workspace/tabs/worktree import type { StructuredChatSleptAtByPaneKey } from '@/store/slices/agent-status/structured-chat-slept-at' export type TerminalActivityTab = Pick -export type BrowserActivityTab = Pick +export type BrowserActivityTab = Pick export function createVisibleWorktreeTerminalActivityProjection( onInspectBucket?: (worktreeId: string) => void @@ -28,8 +28,10 @@ export function getVisibleWorktreeTerminalActivityTabs( } const browserProjection = createWorktreeTabBucketProjection({ - projectTab: (tab) => ({ id: tab.id }), - isSameProjectedTab: (previousTab, nextTab) => previousTab.id === nextTab.id + // A tab Sleep put to rest is not activity, so its mark is part of the projection. + projectTab: (tab) => (tab.sleptAt ? { id: tab.id, sleptAt: tab.sleptAt } : { id: tab.id }), + isSameProjectedTab: (previousTab, nextTab) => + previousTab.id === nextTab.id && previousTab.sleptAt === nextTab.sleptAt }) export function getVisibleWorktreeBrowserActivityTabs( diff --git a/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts b/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts index cee10a49f5c..1204fc6c808 100644 --- a/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts +++ b/src/renderer/src/hooks/ipc-events/mobile-terminal-close-ipc-bridge.ts @@ -2,6 +2,7 @@ import { createRuntimeFilePositionQueue } from './runtime-file-position' import { applyClosedTerminalLeafNotice } from '@/components/terminal-pane/layout/close/closed-terminal-leaf-notice' import { closeTerminalTab } from '@/components/terminal/terminal-tab-actions' import { detectLanguage } from '../../../../shared/editor-language/editor-language-detect' +import { installBrowserTabWakeOnOpen } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { followWorkspaceSleep } from '@/components/sidebar/workspace-actions/sleep/workspace-sleep-follower' import { createProjectMovePauseFollower } from '@/components/sidebar/project-move-pause-follower' import { buildWorkspaceSessionPayload } from '@/lib/workspace/persistence/workspace-session' @@ -218,6 +219,8 @@ export function registerMobileAndTerminalCloseIpcBridge( } else { unsubs.push(window.api.ui.onWorkspaceSleep(followWorkspaceSleep)) } + // Sleep keeps a workspace's browser tabs asleep in place; opening it again wakes them. + unsubs.push(installBrowserTabWakeOnOpen()) unsubs.push( window.api.ui.onResumeSleepingAgents(({ worktreeId }) => { diff --git a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts index 3b233e81f7d..e65f7d500ba 100644 --- a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts +++ b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts @@ -55,7 +55,7 @@ export function readWindowWorkspaceActivityFacts( ) ? 'live' : null, - browser: (state.browserTabsByWorktree[id]?.length ?? 0) > 0, + browser: (state.browserTabsByWorktree[id] ?? []).some((tab) => !tab.sleptAt), structuredChat: structuredChatIds.has(id), agent: agentById.get(id) ?? null } diff --git a/src/renderer/src/lib/worktree-activity-state.ts b/src/renderer/src/lib/worktree-activity-state.ts index 1a2c77300ce..43e6796d084 100644 --- a/src/renderer/src/lib/worktree-activity-state.ts +++ b/src/renderer/src/lib/worktree-activity-state.ts @@ -12,7 +12,8 @@ import { } from '../../../shared/sidebar-list/workspace-activity-facts' type TerminalLikeTab = Pick -type BrowserLikeTab = { id: string } +/** `sleptAt`: Sleep kept the tab but dropped its page; it is not activity until reopened. */ +type BrowserLikeTab = { id: string; sleptAt?: number | null } type TabsByWorktree = Record type PtyIdsByTabId = Record @@ -81,7 +82,7 @@ export function hasActiveWorkspaceActivity( const tabs = tabsByWorktree?.[worktreeId] ?? [] const hasLiveTerminal = ptyIdsByTabId != null && tabs.some((tab) => tabHasLivePty(ptyIdsByTabId, tab.id)) - const hasBrowser = (browserTabsByWorktree?.[worktreeId] ?? []).length > 0 + const hasBrowser = (browserTabsByWorktree?.[worktreeId] ?? []).some((tab) => !tab.sleptAt) // Why: a running agent keeps the workspace visible through brief PTY gaps // such as an SSH reconnect or an unmounted remote pane. #7197 const hasLiveAgent = worktreeIdsWithLiveAgent.has(worktreeId) diff --git a/src/renderer/src/lib/worktree-status.ts b/src/renderer/src/lib/worktree-status.ts index 15f033f11c4..3be51c113c7 100644 --- a/src/renderer/src/lib/worktree-status.ts +++ b/src/renderer/src/lib/worktree-status.ts @@ -63,7 +63,7 @@ const STATUS_LABELS: Record = { export function getWorktreeStatus( tabs: readonly Pick[], - browserTabs: readonly { id: string }[], + browserTabs: readonly { id: string; sleptAt?: number | null }[], ptyIdsByTabId: Record, runtimePaneTitlesByTabId: Record> = {}, options: WorktreeStatusHeuristicOptions = {} @@ -84,7 +84,12 @@ export function getWorktreeStatus( if (options.liveAgentStatus === 'monitoring') { return 'monitoring' } - if (liveTabs.length > 0 || browserTabs.length > 0 || options.hasStructuredChat) { + // A tab Sleep put to rest (sleptAt) keeps its place but is not activity. + if ( + liveTabs.length > 0 || + browserTabs.some((tab) => !tab.sleptAt) || + options.hasStructuredChat + ) { // Why: browser-only and chat-only worktrees (no PTY) are still active from the user's point of view. return 'active' } @@ -199,7 +204,7 @@ export function getWorktreeStatusLabel(status: WorktreeStatus): string { */ export function resolveWorktreeStatus(args: { tabs: readonly Pick[] - browserTabs: readonly { id: string }[] + browserTabs: readonly { id: string; sleptAt?: number | null }[] hasStructuredChat?: boolean ptyIdsByTabId: Record runtimePaneTitlesByTabId?: Record> diff --git a/src/shared/browser-workspace-types.ts b/src/shared/browser-workspace-types.ts index 971c3511d19..c10b99a922f 100644 --- a/src/shared/browser-workspace-types.ts +++ b/src/shared/browser-workspace-types.ts @@ -131,6 +131,11 @@ export type BrowserWorkspace = { createdAt: number /** Mirrored from the active page, like the fields above it. */ docLocation?: BrowserPageDocLocation | null + /** + * Set by Sleep: the tab keeps its place but its page was dropped, and it is not activity until + * the workspace is opened again (then cleared, and the page reloads when shown). + */ + sleptAt?: number } export type BrowserSessionProfileScope = 'default' | 'isolated' | 'imported' diff --git a/src/shared/workspace-layout/workspace-layout-disk-fields.ts b/src/shared/workspace-layout/workspace-layout-disk-fields.ts index a9fa8830526..760dfbd9050 100644 --- a/src/shared/workspace-layout/workspace-layout-disk-fields.ts +++ b/src/shared/workspace-layout/workspace-layout-disk-fields.ts @@ -217,7 +217,9 @@ const BROWSER = { canGoBack: own('browserLive', 'canGoBack'), canGoForward: own('browserLive', 'canGoForward'), loadError: own('browserLive', 'loadError'), - docLocation: own('browserLive', 'docLocation') + docLocation: own('browserLive', 'docLocation'), + // Sleep's mark: runtime-only, so a restart starts every tab awake. + sleptAt: 'unwritten' } as const satisfies Record // Write records only for mounted tree panes; derive keys from tab and leaf IDs. From 4241d8f6e02cc8b5feb9716be413aae2e307da7e Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 21:24:01 -0800 Subject: [PATCH 3/6] fix(sleep): keep the asleep mark outside the layout (asleepBrowserWorktreeIds); sleep writes no layout (NEW-01) --- .../use-worktree-context-menu-model.tsx | 7 +- .../workspace-lineage-menu-actions.ts | 4 +- .../sleep/browser-tab-sleep.test.ts | 50 +++++----- .../sleep/browser-tab-sleep.ts | 93 ++++++++++--------- .../sleep/use-worktree-sleep-state.ts | 4 +- ...e-visible-workspace-kanban-worktree-ids.ts | 3 +- .../activity/use-worktree-activity-status.ts | 7 +- .../use-worktree-activity-statuses.ts | 4 +- .../listing/sleeping-sweep-visibility.ts | 5 +- .../listing/use-visible-worktrees.ts | 5 +- .../visible-worktree-activity-inputs.ts | 8 +- .../visible-worktree-options-from-state.ts | 3 +- .../workspace-activity-shadow.ts | 4 +- .../src/lib/worktree-activity-state.ts | 5 +- src/renderer/src/lib/worktree-status.ts | 11 +-- .../slices/browser/browser-slice-contract.ts | 2 + .../slices/browser/create-browser-slice.ts | 1 + src/shared/browser-workspace-types.ts | 5 - .../workspace-layout-disk-fields.ts | 4 +- 19 files changed, 123 insertions(+), 102 deletions(-) diff --git a/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx b/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx index 469c7cf90fa..990f23049c5 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx +++ b/src/renderer/src/components/sidebar/workspace-actions/context-menu/use-worktree-context-menu-model.tsx @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useCallback, useEffect, useMemo, useRef, useState } from 'react' import { useAppStore } from '@/store' import { useRepoById } from '@/store/repos/use-repository-catalog' @@ -107,7 +108,11 @@ export function useWorktreeContextMenuModel({ selectMenuScopedMap(menuOpen, s.ptyIdsByTabId, EMPTY_PTY_IDS_BY_TAB_ID) ) const browserTabsByWorktree = useAppStore((s) => - selectMenuScopedMap(menuOpen, s.browserTabsByWorktree, EMPTY_BROWSER_TABS_BY_WORKTREE) + selectMenuScopedMap( + menuOpen, + selectAwakeBrowserTabsByWorktree(s), + EMPTY_BROWSER_TABS_BY_WORKTREE + ) ) const unifiedTabsByWorktree = useAppStore((s) => selectMenuScopedMap(menuOpen, s.unifiedTabsByWorktree, EMPTY_UNIFIED_TABS_BY_WORKTREE) diff --git a/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts b/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts index ae45592fd84..645697c35c3 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/context-menu/workspace-lineage-menu-actions.ts @@ -11,7 +11,7 @@ import { getWorkspaceDeleteLineage } from '../deletion/workspace-delete-lineage' type WorkspaceActivityMaps = { tabsByWorktree: Record ptyIdsByTabId: Record - browserTabsByWorktree: Record + browserTabsByWorktree: Record unifiedTabsByWorktree: Record agentStatusByPaneKey: Record structuredChatSleptAtByPaneKey: StructuredChatSleptAtByPaneKey @@ -30,7 +30,7 @@ export function hasSleepableWorkspaceActivity( const tabs = activity.tabsByWorktree[worktreeId] ?? [] return ( tabs.some((tab) => tabHasLivePty(activity.ptyIdsByTabId, tab.id)) || - (activity.browserTabsByWorktree[worktreeId] ?? []).some((tab) => !tab.sleptAt) || + (activity.browserTabsByWorktree[worktreeId] ?? []).length > 0 || // An idle-ended chat still needs Sleep to hide it, even when its legacy tab has no host stamp. (activity.unifiedTabsByWorktree[worktreeId] ?? []).some( (tab) => diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts index 5d46053752d..c83180025f3 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.test.ts @@ -4,27 +4,36 @@ import type { BrowserWorkspace } from '../../../../../../shared/browser-workspac type State = { activeWorktreeId: string | null browserTabsByWorktree: Record - browserPagesByWorkspace: Record + asleepBrowserWorktreeIds: Record + browserPagesByWorkspace: Record activeBrowserTabIdByWorktree: Record } const mocks = vi.hoisted(() => { - const listeners = new Set<(state: unknown) => void>() + const listeners = new Set<(state: State) => void>() + const initial: State = { + activeWorktreeId: null, + browserTabsByWorktree: {}, + asleepBrowserWorktreeIds: {}, + browserPagesByWorkspace: {}, + activeBrowserTabIdByWorktree: {} + } const store = { - state: {} as Record, - getState: () => store.state, - setState: (change: (state: Record) => Record) => { + state: initial, + getState: (): State => store.state, + setState: (change: (state: State) => Partial): void => { store.state = { ...store.state, ...change(store.state) } for (const listener of listeners) { listener(store.state) } }, - subscribe: (listener: (state: unknown) => void) => { + subscribe: (listener: (state: State) => void): (() => void) => { listeners.add(listener) return () => listeners.delete(listener) } } - return { store, evicted: [] as string[] } + const evicted: string[] = [] + return { store, evicted } }) vi.mock('@/store', () => ({ useAppStore: mocks.store })) vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ @@ -32,9 +41,8 @@ vi.mock('@/store/slices/browser/cleanup/browser-webview-cleanup', () => ({ mocks.evicted.push(worktreeId) })) -const { sleepWorktreeBrowserTabs, installBrowserTabWakeOnOpen } = await import( - './browser-tab-sleep' -) +const { sleepWorktreeBrowserTabs, installBrowserTabWakeOnOpen, selectAwakeBrowserTabsByWorktree } = + await import('./browser-tab-sleep') const { isInactiveWorkspace } = await import('@/lib/worktree-activity-state') const tab = (id: string): BrowserWorkspace => ({ @@ -50,13 +58,16 @@ const tab = (id: string): BrowserWorkspace => ({ createdAt: 1 }) -const state = (): State => mocks.store.getState() as unknown as State +const state = (): State => mocks.store.getState() +const inactive = (): boolean => + isInactiveWorkspace('wt', {}, {}, selectAwakeBrowserTabsByWorktree(state()), new Set()) beforeEach(() => { mocks.evicted.length = 0 mocks.store.state = { activeWorktreeId: null, browserTabsByWorktree: { wt: [tab('a'), tab('b'), tab('c')] }, + asleepBrowserWorktreeIds: {}, browserPagesByWorkspace: {}, activeBrowserTabIdByWorktree: { wt: 'b' } } @@ -64,31 +75,28 @@ beforeEach(() => { describe('sleep keeps browser tabs in place (NEW-01)', () => { it('keeps every tab, in order, with the same active tab; drops only their pages', () => { + const before = state().browserTabsByWorktree sleepWorktreeBrowserTabs('wt', 42) expect(mocks.evicted).toEqual(['wt']) + // The layout itself is untouched: same object, same order, same active tab. + expect(state().browserTabsByWorktree).toBe(before) expect(state().browserTabsByWorktree.wt.map((t) => t.id)).toEqual(['a', 'b', 'c']) - expect(state().browserTabsByWorktree.wt.every((t) => t.sleptAt === 42)).toBe(true) expect(state().activeBrowserTabIdByWorktree.wt).toBe('b') }) it('asleep tabs are not activity, so the workspace still reads as asleep', () => { - const inactive = (): boolean => - isInactiveWorkspace('wt', {}, {}, state().browserTabsByWorktree, new Set()) expect(inactive()).toBe(false) sleepWorktreeBrowserTabs('wt', 42) expect(inactive()).toBe(true) }) - it('opening the workspace again wakes its tabs, still in the same order', () => { + it('opening the workspace again wakes its tabs', () => { const stop = installBrowserTabWakeOnOpen() sleepWorktreeBrowserTabs('wt', 42) mocks.store.setState(() => ({ activeWorktreeId: 'wt' })) - expect(state().browserTabsByWorktree.wt.map((t) => [t.id, t.sleptAt])).toEqual([ - ['a', undefined], - ['b', undefined], - ['c', undefined] - ]) - expect(state().activeBrowserTabIdByWorktree.wt).toBe('b') + expect(state().asleepBrowserWorktreeIds).toEqual({}) + expect(inactive()).toBe(false) + expect(state().browserTabsByWorktree.wt.map((t) => t.id)).toEqual(['a', 'b', 'c']) stop() }) }) diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts index 22c63636083..9502292d619 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts @@ -1,45 +1,48 @@ // Sleep never changes a workspace's tab layout (NEW-01). Its browser tabs stay where they are, in -// the same order with the same active tab; only their pages are dropped to free memory, and each -// tab is marked asleep so it no longer counts as activity (an asleep workspace still reads as -// asleep and hides with "Hide sleeping"). Opening the workspace again wakes the tabs: each page -// reloads in place when it is shown. A remote desktop tab's own chrome reconnects it after a wake. +// the same order with the same active tab; only their pages are dropped to free memory, and the +// workspace's tabs are marked asleep so they no longer count as activity (an asleep workspace still +// reads as asleep and hides with "Hide sleeping"). Opening the workspace again wakes them: each +// page reloads in place when it is shown. A remote desktop tab's own chrome reconnects it after a +// wake. The mark lives outside the layout (asleepBrowserWorktreeIds), so sleep writes no layout. import { useAppStore } from '@/store' import { destroyWorktreeBrowserGuests } from '@/store/slices/browser/cleanup/browser-webview-cleanup' import type { BrowserWorkspace } from '../../../../../../shared/browser-workspace-types' -/** Awake tabs are activity; a tab Sleep put to rest is not, until the workspace is opened again. */ -export function isAwakeBrowserTab(tab: { sleptAt?: number | null }): boolean { - return !tab.sleptAt -} +type BrowserTabsByWorktree = Record -export function hasAwakeBrowserTab( - tabs: readonly { sleptAt?: number | null }[] | null | undefined -): boolean { - return (tabs ?? []).some(isAwakeBrowserTab) -} +let cache: { + tabs: BrowserTabsByWorktree + asleep: Record + awake: BrowserTabsByWorktree +} | null = null -function stamp( - tabs: readonly BrowserWorkspace[], - sleptAt: number | undefined -): BrowserWorkspace[] | null { - let changed = false - const next = tabs.map((tab) => { - if ((tab.sleptAt ?? undefined) === sleptAt) { - return tab +/** + * The browser tabs that count as activity: every workspace's, minus those Sleep put to rest. + * Same object back while neither input changes, so store selectors stay stable. + */ +export function selectAwakeBrowserTabsByWorktree(state: { + browserTabsByWorktree: BrowserTabsByWorktree + asleepBrowserWorktreeIds?: Record +}): BrowserTabsByWorktree { + const tabs = state.browserTabsByWorktree + const asleep = state.asleepBrowserWorktreeIds + if (!asleep || Object.keys(asleep).length === 0) { + return tabs + } + if (cache && cache.tabs === tabs && cache.asleep === asleep) { + return cache.awake + } + const awake: BrowserTabsByWorktree = {} + for (const [worktreeId, worktreeTabs] of Object.entries(tabs)) { + if (!asleep[worktreeId]) { + awake[worktreeId] = worktreeTabs } - changed = true - const copy: BrowserWorkspace = { ...tab } - if (sleptAt === undefined) { - delete copy.sleptAt - } else { - copy.sleptAt = sleptAt - } - return copy - }) - return changed ? next : null + } + cache = { tabs, asleep, awake } + return awake } -/** Sleep: drop the pages, keep the tabs, mark them asleep. */ +/** Sleep: drop the pages, keep the tabs, mark the workspace's tabs asleep. */ export function sleepWorktreeBrowserTabs(worktreeId: string, now: number = Date.now()): void { const state = useAppStore.getState() destroyWorktreeBrowserGuests( @@ -47,29 +50,27 @@ export function sleepWorktreeBrowserTabs(worktreeId: string, now: number = Date. state.browserPagesByWorkspace, worktreeId ) - const next = stamp(state.browserTabsByWorktree[worktreeId] ?? [], now) - if (next) { - useAppStore.setState((s) => ({ - browserTabsByWorktree: { ...s.browserTabsByWorktree, [worktreeId]: next } - })) + if ((state.browserTabsByWorktree[worktreeId] ?? []).length === 0) { + return } + useAppStore.setState((s) => ({ + asleepBrowserWorktreeIds: { ...s.asleepBrowserWorktreeIds, [worktreeId]: now } + })) } /** The workspace is open again: its tabs count as activity once more (pages reload when shown). */ export function wakeWorktreeBrowserTabs(worktreeId: string): void { - const tabs = useAppStore.getState().browserTabsByWorktree[worktreeId] - if (!tabs || !tabs.some((tab) => tab.sleptAt)) { + if (!useAppStore.getState().asleepBrowserWorktreeIds?.[worktreeId]) { return } - const next = stamp(tabs, undefined) - if (next) { - useAppStore.setState((s) => ({ - browserTabsByWorktree: { ...s.browserTabsByWorktree, [worktreeId]: next } - })) - } + useAppStore.setState((s) => { + const next = { ...s.asleepBrowserWorktreeIds } + delete next[worktreeId] + return { asleepBrowserWorktreeIds: next } + }) } -/** Wakes a workspace's asleep tabs whenever it becomes the active one (also after an app restart). */ +/** Wakes a workspace's asleep tabs whenever it becomes the active one. */ export function installBrowserTabWakeOnOpen(): () => void { let previous = useAppStore.getState().activeWorktreeId if (previous) { diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts index f60b120aefa..f434606caa5 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/use-worktree-sleep-state.ts @@ -18,6 +18,8 @@ type SleepStateInput = { tabsByWorktree?: Record | null ptyIdsByTabId?: Record | null browserTabsByWorktree?: Record | null + /** Workspaces whose browser tabs Sleep put to rest: those tabs are not activity. */ + asleepBrowserWorktreeIds?: Record unifiedTabsByWorktree?: Record | null structuredChatSleptAtByPaneKey?: StructuredChatSleptAtByPaneKey } @@ -70,7 +72,7 @@ export function selectIsSleepingWorktree(state: SleepStateInput, worktreeId: str worktreeId, state.tabsByWorktree, state.ptyIdsByTabId, - state.browserTabsByWorktree, + state.asleepBrowserWorktreeIds?.[worktreeId] ? null : state.browserTabsByWorktree, selectWorktreeIdsWithLiveAgent(state), getWorktreeIdsWithStructuredChat( state.unifiedTabsByWorktree, diff --git a/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts b/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts index 936433e3ba7..cda31867815 100644 --- a/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts +++ b/src/renderer/src/components/sidebar/workspace-board/surface/use-visible-workspace-kanban-worktree-ids.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useMemo, useState } from 'react' import { useAppStore } from '@/store' import { getAgentStatusEpochNow } from '@/lib/agent-status/evidence/agent-status-epoch-clock' @@ -52,7 +53,7 @@ export function useVisibleWorkspaceKanbanWorktreeIds({ const tabsByWorktree = useAppStore((s) => (!showSleepingWorkspaces ? s.tabsByWorktree : null)) const ptyIdsByTabId = useAppStore((s) => (!showSleepingWorkspaces ? s.ptyIdsByTabId : null)) const browserTabsByWorktree = useAppStore((s) => - !showSleepingWorkspaces ? s.browserTabsByWorktree : null + !showSleepingWorkspaces ? selectAwakeBrowserTabsByWorktree(s) : null ) const worktreeIdsWithStructuredChat = useAppStore((s) => getStructuredChatWorktreeIds( diff --git a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts index a3902e3bac9..f77a9d28fd2 100644 --- a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts +++ b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-status.ts @@ -62,7 +62,12 @@ export function selectWorktreeActivityPtyIds( export function useWorktreeActivityStatus(worktreeId: string): WorktreeStatus { const tabs = useAppStore((s) => s.tabsByWorktree[worktreeId] ?? EMPTY_TABS) - const browserTabs = useAppStore((s) => s.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS) + // Tabs Sleep put to rest stay in the layout but are not activity (NEW-01). + const browserTabs = useAppStore((s) => + s.asleepBrowserWorktreeIds?.[worktreeId] + ? EMPTY_BROWSER_TABS + : (s.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS) + ) const hasStructuredChat = useAppStore((s) => hasAwakeStructuredChat(s.unifiedTabsByWorktree[worktreeId], s.structuredChatSleptAtByPaneKey) ) diff --git a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts index b6fc9e5a473..1ddf10432e9 100644 --- a/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts +++ b/src/renderer/src/components/sidebar/workspace-card/activity/use-worktree-activity-statuses.ts @@ -35,7 +35,9 @@ export function selectWorktreeActivityStatuses( worktreeId, resolveWorktreeStatus({ tabs: statusInputs.tabsByWorktree[worktreeId] ?? EMPTY_TABS, - browserTabs: statusInputs.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS, + browserTabs: statusInputs.asleepBrowserWorktreeIds?.[worktreeId] + ? EMPTY_BROWSER_TABS + : (statusInputs.browserTabsByWorktree[worktreeId] ?? EMPTY_BROWSER_TABS), hasStructuredChat: hasAwakeStructuredChat( statusInputs.unifiedTabsByWorktree[worktreeId], statusInputs.structuredChatSleptAtByPaneKey diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts b/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts index dbb9ad4bcf6..300bd07cc4d 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/sleeping-sweep-visibility.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import type { AppState } from '@/store/types' import type { Worktree } from '../../../../../../shared/worktree/types' import { isSleepingSweepExempt } from '../../../../../../shared/workspace-view/workspace-row-filters' @@ -15,7 +16,9 @@ export function createSleepingSweepHiddenCheck( exemptWorktreeIds?: ReadonlySet ): (worktree: Worktree) => boolean { const tabsByWorktree = getVisibleWorktreeTerminalActivityTabs(state.tabsByWorktree) - const browserTabsByWorktree = getVisibleWorktreeBrowserActivityTabs(state.browserTabsByWorktree) + const browserTabsByWorktree = getVisibleWorktreeBrowserActivityTabs( + selectAwakeBrowserTabsByWorktree(state) + ) const liveAgentWorktrees = getWorktreeIdsWithLiveAgent( state.agentStatusByPaneKey, tabsByWorktree, diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts index c33f953ca27..4f3de102ea5 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { selectSidebarLineageParentIdentities } from '@/store/slices/worktrees/metadata/cross-store-lineage-parents' import { useMemo, useState } from 'react' import { shallow } from 'zustand/shallow' @@ -93,7 +94,9 @@ export function useVisibleSidebarWorktrees(args: { ) const ptyIdsByTabId = useAppStore((s) => (needsActivityMaps ? s.ptyIdsByTabId : null)) const browserTabsByWorktree = useAppStore((s) => - !showSleepingWorkspaces ? getVisibleWorktreeBrowserActivityTabs(s.browserTabsByWorktree) : null + !showSleepingWorkspaces + ? getVisibleWorktreeBrowserActivityTabs(selectAwakeBrowserTabsByWorktree(s)) + : null ) const worktreeIdsWithStructuredChat = useAppStore((s) => getStructuredChatWorktreeIds( diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts index 33687dbae47..df576d451e9 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-activity-inputs.ts @@ -7,7 +7,7 @@ import { createWorktreeTabBucketProjection } from '@/lib/workspace/tabs/worktree import type { StructuredChatSleptAtByPaneKey } from '@/store/slices/agent-status/structured-chat-slept-at' export type TerminalActivityTab = Pick -export type BrowserActivityTab = Pick +export type BrowserActivityTab = Pick export function createVisibleWorktreeTerminalActivityProjection( onInspectBucket?: (worktreeId: string) => void @@ -28,10 +28,8 @@ export function getVisibleWorktreeTerminalActivityTabs( } const browserProjection = createWorktreeTabBucketProjection({ - // A tab Sleep put to rest is not activity, so its mark is part of the projection. - projectTab: (tab) => (tab.sleptAt ? { id: tab.id, sleptAt: tab.sleptAt } : { id: tab.id }), - isSameProjectedTab: (previousTab, nextTab) => - previousTab.id === nextTab.id && previousTab.sleptAt === nextTab.sleptAt + projectTab: (tab) => ({ id: tab.id }), + isSameProjectedTab: (previousTab, nextTab) => previousTab.id === nextTab.id }) export function getVisibleWorktreeBrowserActivityTabs( diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts index cdfb00e5052..cc31b9b8cc8 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts @@ -1,3 +1,4 @@ +import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { selectSidebarLineageParentIdentities } from '@/store/slices/worktrees/metadata/cross-store-lineage-parents' import type { Repo } from '../../../../../../shared/repo-types' import { getSettingsFocusedExecutionHostId } from '../../../../../../shared/execution-host' @@ -20,7 +21,7 @@ export function buildVisibleWorktreeOptionsFromState( showSleepingWorkspaces: state.showSleepingWorkspaces, tabsByWorktree: state.tabsByWorktree, ptyIdsByTabId: state.ptyIdsByTabId, - browserTabsByWorktree: state.browserTabsByWorktree, + browserTabsByWorktree: selectAwakeBrowserTabsByWorktree(state), worktreeIdsWithLiveAgent: getWorktreeIdsWithLiveAgent( state.agentStatusByPaneKey, state.tabsByWorktree, diff --git a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts index e65f7d500ba..4d93f604c34 100644 --- a/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts +++ b/src/renderer/src/lib/sidebar-shadow/workspace-activity-shadow.ts @@ -26,6 +26,7 @@ export function readWindowWorkspaceActivityFacts( | 'tabsByWorktree' | 'ptyIdsByTabId' | 'browserTabsByWorktree' + | 'asleepBrowserWorktreeIds' | 'unifiedTabsByWorktree' | 'agentStatusByPaneKey' > & @@ -55,7 +56,8 @@ export function readWindowWorkspaceActivityFacts( ) ? 'live' : null, - browser: (state.browserTabsByWorktree[id] ?? []).some((tab) => !tab.sleptAt), + browser: + !state.asleepBrowserWorktreeIds?.[id] && (state.browserTabsByWorktree[id]?.length ?? 0) > 0, structuredChat: structuredChatIds.has(id), agent: agentById.get(id) ?? null } diff --git a/src/renderer/src/lib/worktree-activity-state.ts b/src/renderer/src/lib/worktree-activity-state.ts index 43e6796d084..1a2c77300ce 100644 --- a/src/renderer/src/lib/worktree-activity-state.ts +++ b/src/renderer/src/lib/worktree-activity-state.ts @@ -12,8 +12,7 @@ import { } from '../../../shared/sidebar-list/workspace-activity-facts' type TerminalLikeTab = Pick -/** `sleptAt`: Sleep kept the tab but dropped its page; it is not activity until reopened. */ -type BrowserLikeTab = { id: string; sleptAt?: number | null } +type BrowserLikeTab = { id: string } type TabsByWorktree = Record type PtyIdsByTabId = Record @@ -82,7 +81,7 @@ export function hasActiveWorkspaceActivity( const tabs = tabsByWorktree?.[worktreeId] ?? [] const hasLiveTerminal = ptyIdsByTabId != null && tabs.some((tab) => tabHasLivePty(ptyIdsByTabId, tab.id)) - const hasBrowser = (browserTabsByWorktree?.[worktreeId] ?? []).some((tab) => !tab.sleptAt) + const hasBrowser = (browserTabsByWorktree?.[worktreeId] ?? []).length > 0 // Why: a running agent keeps the workspace visible through brief PTY gaps // such as an SSH reconnect or an unmounted remote pane. #7197 const hasLiveAgent = worktreeIdsWithLiveAgent.has(worktreeId) diff --git a/src/renderer/src/lib/worktree-status.ts b/src/renderer/src/lib/worktree-status.ts index 3be51c113c7..15f033f11c4 100644 --- a/src/renderer/src/lib/worktree-status.ts +++ b/src/renderer/src/lib/worktree-status.ts @@ -63,7 +63,7 @@ const STATUS_LABELS: Record = { export function getWorktreeStatus( tabs: readonly Pick[], - browserTabs: readonly { id: string; sleptAt?: number | null }[], + browserTabs: readonly { id: string }[], ptyIdsByTabId: Record, runtimePaneTitlesByTabId: Record> = {}, options: WorktreeStatusHeuristicOptions = {} @@ -84,12 +84,7 @@ export function getWorktreeStatus( if (options.liveAgentStatus === 'monitoring') { return 'monitoring' } - // A tab Sleep put to rest (sleptAt) keeps its place but is not activity. - if ( - liveTabs.length > 0 || - browserTabs.some((tab) => !tab.sleptAt) || - options.hasStructuredChat - ) { + if (liveTabs.length > 0 || browserTabs.length > 0 || options.hasStructuredChat) { // Why: browser-only and chat-only worktrees (no PTY) are still active from the user's point of view. return 'active' } @@ -204,7 +199,7 @@ export function getWorktreeStatusLabel(status: WorktreeStatus): string { */ export function resolveWorktreeStatus(args: { tabs: readonly Pick[] - browserTabs: readonly { id: string; sleptAt?: number | null }[] + browserTabs: readonly { id: string }[] hasStructuredChat?: boolean ptyIdsByTabId: Record runtimePaneTitlesByTabId?: Record> 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 fe5f62d6496..8b28afd32ee 100644 --- a/src/renderer/src/store/slices/browser/browser-slice-contract.ts +++ b/src/renderer/src/store/slices/browser/browser-slice-contract.ts @@ -116,6 +116,8 @@ export type BrowserCookieImportExecutionResult = BrowserCookieImportResult & { export type BrowserSlice = { browserTabsByWorktree: Record + /** Workspaces whose tabs Sleep put to rest (when): kept in the layout, not activity (NEW-01). */ + asleepBrowserWorktreeIds: Record browserPagesByWorkspace: Record browserCertificateFailuresByPageId: Record /** May precede the page record (client-hosted pages); main's false on guest teardown clears it. */ diff --git a/src/renderer/src/store/slices/browser/create-browser-slice.ts b/src/renderer/src/store/slices/browser/create-browser-slice.ts index 080e4561564..519b168186f 100644 --- a/src/renderer/src/store/slices/browser/create-browser-slice.ts +++ b/src/renderer/src/store/slices/browser/create-browser-slice.ts @@ -23,6 +23,7 @@ import { createBrowserHistoryActions } from './history/browser-history-actions' export const createBrowserSlice: StateCreator = (set, get) => ({ browserTabsByWorktree: {}, + asleepBrowserWorktreeIds: {}, browserPagesByWorkspace: {}, browserCertificateFailuresByPageId: {}, browserAudiblePageIds: {}, diff --git a/src/shared/browser-workspace-types.ts b/src/shared/browser-workspace-types.ts index c10b99a922f..971c3511d19 100644 --- a/src/shared/browser-workspace-types.ts +++ b/src/shared/browser-workspace-types.ts @@ -131,11 +131,6 @@ export type BrowserWorkspace = { createdAt: number /** Mirrored from the active page, like the fields above it. */ docLocation?: BrowserPageDocLocation | null - /** - * Set by Sleep: the tab keeps its place but its page was dropped, and it is not activity until - * the workspace is opened again (then cleared, and the page reloads when shown). - */ - sleptAt?: number } export type BrowserSessionProfileScope = 'default' | 'isolated' | 'imported' diff --git a/src/shared/workspace-layout/workspace-layout-disk-fields.ts b/src/shared/workspace-layout/workspace-layout-disk-fields.ts index 760dfbd9050..a9fa8830526 100644 --- a/src/shared/workspace-layout/workspace-layout-disk-fields.ts +++ b/src/shared/workspace-layout/workspace-layout-disk-fields.ts @@ -217,9 +217,7 @@ const BROWSER = { canGoBack: own('browserLive', 'canGoBack'), canGoForward: own('browserLive', 'canGoForward'), loadError: own('browserLive', 'loadError'), - docLocation: own('browserLive', 'docLocation'), - // Sleep's mark: runtime-only, so a restart starts every tab awake. - sleptAt: 'unwritten' + docLocation: own('browserLive', 'docLocation') } as const satisfies Record // Write records only for mounted tree panes; derive keys from tab and leaf IDs. From 759672bab36aa432ae8d7bccd8303acec9d8b61e Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 21:25:39 -0800 Subject: [PATCH 4/6] fix(sleep): visibility options read the asleep mark too (NEW-01) --- .../worktree-list/listing/compute-visible-worktrees.ts | 2 ++ .../worktree-list/listing/desktop-workspace-row-facts.ts | 3 ++- .../listing/visible-worktree-options-from-state.ts | 4 ++-- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts index 5539a3a3193..c7fa50c2a9a 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/compute-visible-worktrees.ts @@ -19,6 +19,8 @@ export type VisibleWorktreeOptions = { tabsByWorktree: Record[]> | null ptyIdsByTabId: Record | null browserTabsByWorktree?: Record | null + /** Workspaces whose browser tabs Sleep put to rest: those tabs are not activity (NEW-01). */ + asleepBrowserWorktreeIds?: Record worktreeIdsWithLiveAgent: ReadonlySet worktreeIdsWithStructuredChat?: ReadonlySet hideDefaultBranchWorkspace: boolean diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts b/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts index bbf8798e922..e0fe22d7fe3 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/desktop-workspace-row-facts.ts @@ -23,6 +23,7 @@ export type DesktopWorkspaceRowFactInputs = { tabsByWorktree: Record[]> | null ptyIdsByTabId: Record | null browserTabsByWorktree?: Record | null + asleepBrowserWorktreeIds?: Record worktreeIdsWithLiveAgent: ReadonlySet worktreeIdsWithStructuredChat?: ReadonlySet /** Rows in a PTY-rebind grace window; read as unverifiable, never as asleep (#15996). */ @@ -54,7 +55,7 @@ export function buildDesktopWorkspaceRowFactReader( worktree.id, inputs.tabsByWorktree, inputs.ptyIdsByTabId, - inputs.browserTabsByWorktree, + inputs.asleepBrowserWorktreeIds?.[worktree.id] ? null : inputs.browserTabsByWorktree, inputs.worktreeIdsWithLiveAgent, inputs.worktreeIdsWithStructuredChat ) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts index cc31b9b8cc8..c3500996b40 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/visible-worktree-options-from-state.ts @@ -1,4 +1,3 @@ -import { selectAwakeBrowserTabsByWorktree } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { selectSidebarLineageParentIdentities } from '@/store/slices/worktrees/metadata/cross-store-lineage-parents' import type { Repo } from '../../../../../../shared/repo-types' import { getSettingsFocusedExecutionHostId } from '../../../../../../shared/execution-host' @@ -21,7 +20,8 @@ export function buildVisibleWorktreeOptionsFromState( showSleepingWorkspaces: state.showSleepingWorkspaces, tabsByWorktree: state.tabsByWorktree, ptyIdsByTabId: state.ptyIdsByTabId, - browserTabsByWorktree: selectAwakeBrowserTabsByWorktree(state), + browserTabsByWorktree: state.browserTabsByWorktree, + asleepBrowserWorktreeIds: state.asleepBrowserWorktreeIds, worktreeIdsWithLiveAgent: getWorktreeIdsWithLiveAgent( state.agentStatusByPaneKey, state.tabsByWorktree, From ae88c27e61545aa4907006cb3cdc9e22c11182e3 Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 22:21:24 -0800 Subject: [PATCH 5/6] fix(sleep): a slept VM's browser pages reopen at their URL after the wake instead of closing their tabs (NEW-01) --- .../use-remote-browser-page-lifecycle.ts | 12 ++++++++++++ .../workspace-actions/sleep/browser-tab-sleep.ts | 15 +++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts index 5870a9ccb9b..b567d06920e 100644 --- a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts +++ b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts @@ -1,3 +1,4 @@ +import { consumeReopenAfterSleep } from '@/components/sidebar/workspace-actions/sleep/browser-tab-sleep' import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' import { useAppStore } from '@/store' import { runtimeEnvironmentIdOrLocalUnlessTwin } from '@/lib/workspace/ownership/worktree-runtime-owner' @@ -147,6 +148,17 @@ export function useRemoteBrowserPageLifecycle({ state.removeRemoteBrowserPageHandle(browserTab.id, remotePageId) } lifecycle.abandonRemotePage() + // Slept with its VM (NEW-01): the tab stays. While asleep it waits; once the workspace is + // open again it opens a new host page at its URL. + if (state.asleepBrowserWorktreeIds[browserTab.worktreeId]) { + clearStreamFrame() + return + } + if (consumeReopenAfterSleep(browserTab.id)) { + clearStreamFrame() + lifecycle.open() + return + } if (remoteViewportTimerRef.current !== null) { window.clearTimeout(remoteViewportTimerRef.current) remoteViewportTimerRef.current = null diff --git a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts index 9502292d619..fc62a3a8d2e 100644 --- a/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts +++ b/src/renderer/src/components/sidebar/workspace-actions/sleep/browser-tab-sleep.ts @@ -42,9 +42,24 @@ export function selectAwakeBrowserTabsByWorktree(state: { return awake } +// Pages a host ran (an Orca Cloud VM's browser) are gone after the VM sleeps. When such a page is +// reported missing after the wake, its tab opens a new page at the same URL instead of closing. +const reopenAfterSleep = new Set() + +/** True once per slept page: the pane recreates the host page instead of closing the tab. */ +export function consumeReopenAfterSleep(browserPageId: string): boolean { + return reopenAfterSleep.delete(browserPageId) +} + /** Sleep: drop the pages, keep the tabs, mark the workspace's tabs asleep. */ export function sleepWorktreeBrowserTabs(worktreeId: string, now: number = Date.now()): void { const state = useAppStore.getState() + for (const tab of state.browserTabsByWorktree[worktreeId] ?? []) { + reopenAfterSleep.add(tab.id) + for (const page of state.browserPagesByWorkspace[tab.id] ?? []) { + reopenAfterSleep.add(page.id) + } + } destroyWorktreeBrowserGuests( state.browserTabsByWorktree, state.browserPagesByWorkspace, From ab7bde85ba4fe70fccb0c4f01353ccc57a2da617 Mon Sep 17 00:00:00 2001 From: Neil Date: Tue, 10 Nov 2026 22:57:06 -0800 Subject: [PATCH 6/6] fix(cloud): closeMissingRemotePage depends on browserTab.worktreeId (exhaustive-deps) --- .../stream-remote/use-remote-browser-page-lifecycle.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts index b567d06920e..7d894746866 100644 --- a/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts +++ b/src/renderer/src/components/browser-pane/stream-remote/use-remote-browser-page-lifecycle.ts @@ -178,6 +178,7 @@ export function useRemoteBrowserPageLifecycle({ [ browserTab.id, browserTab.workspaceId, + browserTab.worktreeId, clearStreamFrame, closeBrowserPage, closeBrowserTab,