@cerbur/clutch-dsh-worktree 0.1.4 → 0.1.6

package/lib/client/WorktreeSurface.js

@@ -1,16 +1,18 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
 import { IconBranchOutline16, IconCloseOutline16, IconPlusOutline16, IconSearchOutline16, } from '@deepseek-ai/dsh-client-ui-primitives';
 import { openWorktreeSession } from './navigation.js';
 import { useSidebarOverlayGeometry } from './sidebar-overlay-geometry.js';
+import { isMainExpanded, isWorkspaceExpanded, isWorktreeExpanded, } from './worktree-expand-state.js';
 import { effectiveViewMode, unboundSessionIds, workspaceSessionIds } from './view-mode.js';
 import { formatWorktreeViewError } from './worktree-error-copy.js';
 import { filterVisibleSessionIds, sessionMatchesQuery, } from './session-view.js';
 import { retryWorktreeSessionBinding } from './worktree-session.js';
 import { WorktreeCreateDialog, WorktreeRemovalDialog, WorktreeSessionRenameDialog, WorktreeWorkspaceDeleteDialog, WorktreeWorkspaceRenameDialog, } from './worktree-surface-dialogs.js';
-import { bindingIdsFor, includesText, workspaceMatches, } from './worktree-surface-selectors.js';
+import { bindingIdsFor, clearSessionGroupExpansion, includesText, isCompleteWorktreeWorkspaceSnapshot, currentSessionRevealKeys, resolveCurrentSessionLocation, workspaceMatches, } from './worktree-surface-selectors.js';
+import { scrollCurrentSessionIntoView } from './worktree-session-position.js';
 import { WorktreeGroupRow, WorktreeSessionGroup, WorktreeWorkspaceRow, } from './worktree-surface-rows.js';
-import { executeWorktreeAction, createDefaultWorktreeName, createWorktreeRefreshGuard, filterArchivedSessionIds, loadWorktreeViews, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, } from './worktree-view.js';
+import { executeWorktreeAction, createDefaultWorktreeName, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, loadWorktreeViews, mergeWorktreeView, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, } from './worktree-view.js';
 import styles from './worktree.css';
 function toNativeWorktreeViewError(error) {
     const viewError = toWorktreeViewError(error);
@@ -31,20 +33,29 @@ function useStableWorkspaceIds(workspaces) {
  * Peer Worktree navigation surface. It keeps the original DSH Workspace mode
  * intact and renders a browser-local Workspace → Worktree → Session projection.
  */
-export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces, t, available, manager, invalidateWorktreeContext, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, insertWorktreeBefore, renameSession, forkSession, archiveSession, ensureSessionWorkspace, syncSessionWorkspaces, openSession, }) {
+export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces, t, available, expandState, manager, invalidateWorktreeContext, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, insertWorktreeBefore, renameSession, forkSession, archiveSession, ensureSessionWorkspace, syncSessionWorkspaces, openSession, }) {
     const preferredMode = useStore((state) => state.viewMode);
     const mode = effectiveViewMode(preferredMode, available && manager !== undefined);
     const sessions = useSessions((state) => state);
     const workspaces = useWorkspaces((state) => state);
+    const currentSessionId = sessions.current;
     const workspaceIds = useStableWorkspaceIds(workspaces.items);
     const [readState, setReadState] = useState(EMPTY_READ_STATE);
+    const expandSnapshot = useSyncExternalStore(expandState.subscribe, expandState.getSnapshot, expandState.getSnapshot);
     const readStateRef = useRef(readState);
     readStateRef.current = readState;
     const [searchQuery, setSearchQuery] = useState('');
-    const [expandedWorkspaces, setExpandedWorkspaces] = useState({});
-    const [expandedMains, setExpandedMains] = useState({});
-    const [expandedWorktrees, setExpandedWorktrees] = useState({});
+    const [currentSessionReveal, setCurrentSessionReveal] = useState();
+    const searchQueryRef = useRef(searchQuery);
+    searchQueryRef.current = searchQuery;
+    const locateGenerationRef = useRef(0);
+    const positionedLocateGenerationRef = useRef();
     const [worktreeModalWorkspaceId, setWorktreeModalWorkspaceId] = useState();
+    const [modalReadError, setModalReadError] = useState();
+    const [modalReadLoading, setModalReadLoading] = useState(false);
+    const [worktreeModalMode, setWorktreeModalMode] = useState('create');
+    const [importCandidates, setImportCandidates] = useState({ status: 'idle', candidates: [] });
+    const [selectedImportPath, setSelectedImportPath] = useState();
     const [openWorkspaceMenuId, setOpenWorkspaceMenuId] = useState();
     const [openWorktreeMenuId, setOpenWorktreeMenuId] = useState();
     const [worktreeRemoval, setWorktreeRemoval] = useState();
@@ -72,6 +83,11 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [worktreeDrag, setWorktreeDrag] = useState();
     const worktreeDropCommitted = useRef(false);
     const refreshGuard = useRef(createWorktreeRefreshGuard());
+    const modalReadLoader = useRef(createWorktreeModalViewLoader());
+    const modalReadViewRef = useRef();
+    const importCandidatesGuard = useRef(createWorktreeRefreshGuard());
+    const modalWorkspaceIdRef = useRef(worktreeModalWorkspaceId);
+    modalWorkspaceIdRef.current = worktreeModalWorkspaceId;
     const { ref, width, bounds } = useSidebarOverlayGeometry(mode === 'worktree');
     const collapsed = width <= 64;
     const query = searchQuery.trim().toLocaleLowerCase();
@@ -92,23 +108,59 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             invalidateContext: options.invalidateContext !== false,
             invalidateWorktreeContext,
         }), (views) => {
-            setReadState({ status: 'ready', views });
+            setReadState({
+                status: 'ready',
+                views: modalReadViewRef.current === undefined
+                    ? views
+                    : mergeWorktreeView(views, modalReadViewRef.current),
+            });
         }, (error) => {
             if (preserveCurrent)
                 throw error;
             setReadState({
                 status: 'error',
-                views: [],
+                views: modalReadViewRef.current === undefined
+                    ? []
+                    : [modalReadViewRef.current],
                 error: toWorktreeViewError(error),
             });
         });
     }, [invalidateWorktreeContext, manager, workspaceIds]);
+    const loadModalWorktreeView = useCallback((workspaceId) => {
+        setModalReadError(undefined);
+        setModalReadLoading(true);
+        if (manager === undefined) {
+            setModalReadLoading(false);
+            setModalReadError({
+                code: 'WORKTREE_VIEW_UNAVAILABLE',
+                message: '',
+                retryable: true,
+            });
+            return;
+        }
+        void modalReadLoader.current.load(manager, workspaceId, (view) => {
+            modalReadViewRef.current = view;
+            setModalReadLoading(false);
+            setReadState((current) => ({
+                ...current,
+                views: mergeWorktreeView(current.views, view),
+            }));
+        }, (error) => {
+            setModalReadLoading(false);
+            setModalReadError(toWorktreeViewError(error));
+        });
+    }, [manager]);
     useEffect(() => {
         if (mode === 'worktree') {
             void refresh({ preserveCurrent: readStateRef.current.status === 'ready' });
         }
         else {
             refreshGuard.current.invalidate();
+            modalReadLoader.current.invalidate();
+            modalReadViewRef.current = undefined;
+            setWorktreeModalWorkspaceId(undefined);
+            setModalReadError(undefined);
+            setModalReadLoading(false);
             setReadState(EMPTY_READ_STATE);
         }
     }, [mode, refresh]);
@@ -121,6 +173,63 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         }))));
     }, [readState.status, readState.views, syncSessionWorkspaces]);
     const viewByWorkspace = useMemo(() => new Map(readState.views.map((view) => [view.workspaceId, view])), [readState.views]);
+    const currentSessionLocation = useMemo(() => readState.status === 'ready'
+        ? resolveCurrentSessionLocation(currentSessionId, workspaces.items, readState.views)
+        : undefined, [currentSessionId, readState.status, readState.views, workspaces.items]);
+    const currentRevealKeys = useMemo(() => new Set(currentSessionRevealKeys(currentSessionLocation)), [currentSessionLocation]);
+    const isCurrentSessionReveal = (key) => currentSessionReveal !== undefined &&
+        currentSessionReveal.sessionId === currentSessionId &&
+        currentRevealKeys.has(key) &&
+        currentSessionReveal.suppressedKeys[key] !== true;
+    useLayoutEffect(() => {
+        locateGenerationRef.current += 1;
+        positionedLocateGenerationRef.current = undefined;
+        if (mode !== 'worktree') {
+            setCurrentSessionReveal(undefined);
+            return;
+        }
+        if (searchQueryRef.current.trim().length > 0)
+            setSearchQuery('');
+        setCurrentSessionReveal(currentSessionId === undefined
+            ? undefined
+            : { sessionId: currentSessionId, suppressedKeys: {} });
+    }, [currentSessionId, mode]);
+    useLayoutEffect(() => {
+        if (mode !== 'worktree' ||
+            currentSessionId === undefined ||
+            currentSessionLocation === undefined) {
+            return;
+        }
+        const generation = locateGenerationRef.current;
+        if (positionedLocateGenerationRef.current === generation)
+            return;
+        let cancelled = false;
+        const frame = requestAnimationFrame(() => {
+            if (cancelled || generation !== locateGenerationRef.current)
+                return;
+            if (!scrollCurrentSessionIntoView(ref.current, currentSessionId))
+                return;
+            positionedLocateGenerationRef.current = generation;
+        });
+        return () => {
+            cancelled = true;
+            cancelAnimationFrame(frame);
+        };
+    }, [
+        currentSessionId,
+        currentSessionLocation,
+        currentSessionReveal,
+        expandSnapshot,
+        mode,
+        query,
+        readState.status,
+    ]);
+    useEffect(() => {
+        if (readState.status !== 'ready' ||
+            !isCompleteWorktreeWorkspaceSnapshot(workspaceIds, readState.views))
+            return;
+        expandState.actions.retain(workspaceIds, readState.views.flatMap((view) => view.worktrees.map((record) => record.worktreeId)));
+    }, [expandState, readState.status, readState.views, workspaceIds]);
     const modalWorkspace = workspaces.items.find((workspace) => workspace.workspaceId === worktreeModalWorkspaceId);
     const modalView = worktreeModalWorkspaceId === undefined
         ? undefined
@@ -131,15 +240,27 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         : modalReadiness?.status === 'ready'
             ? modalView.branches.length === 0 ? 'noLocalBranch' : undefined
             : modalReadiness?.status;
-    const modalCanCreate = modalSetupStatus === undefined && modalReadiness?.status === 'ready';
+    const modalCanCreate = !modalReadLoading &&
+        modalSetupStatus === undefined &&
+        modalReadiness?.status === 'ready';
     useEffect(() => {
         if (worktreeModalWorkspaceId === undefined || modalView === undefined)
             return;
         if (modalView.readiness.status !== 'ready') {
             setSelectedBranch('');
+            setNewBranch('');
             return;
         }
         setSelectedBranch((current) => reconcileBaseBranchSelection(current, modalView.branches));
+        setNewBranch((current) => {
+            if (current.length > 0)
+                return current;
+            const existingNames = [
+                ...modalView.branches.map((branch) => branch.name),
+                ...modalView.worktrees.map((worktree) => worktree.branch),
+            ];
+            return createDefaultWorktreeName(existingNames);
+        });
     }, [modalView, worktreeModalWorkspaceId]);
     const runMutation = async (operation) => {
         setActionPending(true);
@@ -155,6 +276,24 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             setActionPending(false);
         }
     };
+    const loadImportCandidates = useCallback(async (workspaceId) => {
+        if (manager === undefined)
+            return;
+        setImportCandidates((current) => ({ status: 'loading', candidates: current.candidates }));
+        await importCandidatesGuard.current.run(() => manager.listImportCandidates({ workspaceId }), (candidates) => {
+            if (modalWorkspaceIdRef.current !== workspaceId)
+                return;
+            setImportCandidates({ status: 'ready', candidates });
+        }, (error) => {
+            if (modalWorkspaceIdRef.current !== workspaceId)
+                return;
+            setImportCandidates((current) => ({
+                status: 'error',
+                candidates: current.candidates,
+                error: toWorktreeViewError(error),
+            }));
+        });
+    }, [manager]);
     const workspaceRenameTrimmed = workspaceRenameDraft.trim();
     const workspaceRenameDuplicate = workspaceRenameTarget !== undefined &&
         workspaceRenameTrimmed.length > 0 &&
@@ -373,91 +512,201 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             return;
         await runMutation(() => archiveSession(sessionId));
     };
+    const clearSessionGroups = (groupKeys) => {
+        if (groupKeys.length === 0)
+            return;
+        setExpandedSessionGroups((current) => clearSessionGroupExpansion(current, groupKeys));
+    };
+    const suppressCurrentSessionReveal = (key) => {
+        if (!isCurrentSessionReveal(key))
+            return false;
+        setCurrentSessionReveal((current) => {
+            if (current === undefined || current.sessionId !== currentSessionId)
+                return current;
+            return {
+                ...current,
+                suppressedKeys: { ...current.suppressedKeys, [key]: true },
+            };
+        });
+        return true;
+    };
     const toggleWorkspace = (workspaceId) => {
-        setExpandedWorkspaces((current) => ({
-            ...current,
-            [workspaceId]: current[workspaceId] === false,
-        }));
+        const persistedExpanded = isWorkspaceExpanded(expandSnapshot, workspaceId);
+        const autoExpanded = isCurrentSessionReveal('workspace:' + workspaceId);
+        const visuallyExpanded = persistedExpanded || autoExpanded;
+        if (visuallyExpanded && autoExpanded) {
+            suppressCurrentSessionReveal('workspace:' + workspaceId);
+        }
+        if (visuallyExpanded && !persistedExpanded) {
+            clearSessionGroups([
+                'main:' + workspaceId,
+                ...(viewByWorkspace.get(workspaceId)?.worktrees.map((record) => record.worktreeId) ?? []).map((worktreeId) => 'worktree:' + worktreeId),
+            ]);
+            return;
+        }
+        expandState.actions.toggleWorkspace(workspaceId);
+        if (visuallyExpanded) {
+            clearSessionGroups([
+                'main:' + workspaceId,
+                ...(viewByWorkspace.get(workspaceId)?.worktrees.map((record) => record.worktreeId) ?? []).map((worktreeId) => 'worktree:' + worktreeId),
+            ]);
+        }
     };
     const toggleMain = (workspaceId) => {
-        setExpandedMains((current) => ({
-            ...current,
-            [workspaceId]: current[workspaceId] === false,
-        }));
+        const persistedExpanded = isMainExpanded(expandSnapshot, workspaceId);
+        const autoExpanded = isCurrentSessionReveal('main:' + workspaceId);
+        const visuallyExpanded = persistedExpanded || autoExpanded;
+        if (visuallyExpanded && autoExpanded) {
+            suppressCurrentSessionReveal('main:' + workspaceId);
+        }
+        if (visuallyExpanded && !persistedExpanded) {
+            clearSessionGroups(['main:' + workspaceId]);
+            return;
+        }
+        expandState.actions.toggleMain(workspaceId);
+        if (visuallyExpanded)
+            clearSessionGroups(['main:' + workspaceId]);
     };
     const toggleWorktree = (worktreeId) => {
-        setExpandedWorktrees((current) => ({
+        const persistedExpanded = isWorktreeExpanded(expandSnapshot, worktreeId);
+        const autoExpanded = isCurrentSessionReveal('worktree:' + worktreeId);
+        const visuallyExpanded = persistedExpanded || autoExpanded;
+        if (visuallyExpanded && autoExpanded) {
+            suppressCurrentSessionReveal('worktree:' + worktreeId);
+        }
+        if (visuallyExpanded && !persistedExpanded) {
+            clearSessionGroups(['worktree:' + worktreeId]);
+            return;
+        }
+        expandState.actions.toggleWorktree(worktreeId);
+        if (visuallyExpanded)
+            clearSessionGroups(['worktree:' + worktreeId]);
+    };
+    const toggleSessionGroup = (groupKey) => {
+        const autoExpanded = isCurrentSessionReveal('session-group:' + groupKey);
+        const transientExpanded = expandedSessionGroups[groupKey] === true;
+        if (autoExpanded) {
+            suppressCurrentSessionReveal('session-group:' + groupKey);
+            setExpandedSessionGroups((current) => {
+                const next = { ...current };
+                delete next[groupKey];
+                return next;
+            });
+            return;
+        }
+        setExpandedSessionGroups((current) => ({
             ...current,
-            [worktreeId]: current[worktreeId] === false,
+            [groupKey]: !transientExpanded,
         }));
     };
+    const closeWorktreeCreator = (force = false) => {
+        if (actionPending && !force)
+            return;
+        modalReadLoader.current.invalidate();
+        modalReadViewRef.current = undefined;
+        importCandidatesGuard.current.invalidate();
+        setWorktreeModalWorkspaceId(undefined);
+        setModalReadError(undefined);
+        setModalReadLoading(false);
+    };
     const openWorktreeCreator = (workspace) => {
         const view = viewByWorkspace.get(workspace.workspaceId);
-        const baseBranch = selectDefaultBaseBranch(view?.branches ?? []);
-        const existingNames = [
-            ...(view?.branches ?? []).map((branch) => branch.name),
-            ...(view?.worktrees ?? []).map((worktree) => worktree.branch),
-        ];
+        modalReadLoader.current.invalidate();
+        modalReadViewRef.current = undefined;
+        importCandidatesGuard.current.invalidate();
         setWorktreeModalWorkspaceId(workspace.workspaceId);
-        setSelectedBranch(baseBranch);
-        setNewBranch(createDefaultWorktreeName(existingNames));
+        setWorktreeModalMode('create');
+        setImportCandidates({ status: 'idle', candidates: [] });
+        setSelectedImportPath(undefined);
         setActionError(undefined);
+        setModalReadError(undefined);
+        setModalReadLoading(false);
+        if (view === undefined) {
+            setSelectedBranch('');
+            setNewBranch('');
+            loadModalWorktreeView(workspace.workspaceId);
+            return;
+        }
+        setSelectedBranch(selectDefaultBaseBranch(view.branches));
+        setNewBranch(createDefaultWorktreeName([
+            ...view.branches.map((branch) => branch.name),
+            ...view.worktrees.map((worktree) => worktree.branch),
+        ]));
     };
-    const submitWorktree = async () => {
-        const worktreeName = newBranch.trim();
-        if (manager === undefined ||
-            modalWorkspace === undefined ||
-            !modalCanCreate ||
-            selectedBranch.length === 0 ||
-            worktreeName.length === 0) {
+    const changeWorktreeModalMode = (mode) => {
+        setWorktreeModalMode(mode);
+        if (mode === 'import' &&
+            worktreeModalWorkspaceId !== undefined &&
+            importCandidates.status === 'idle') {
+            void loadImportCandidates(worktreeModalWorkspaceId);
+        }
+    };
+    const continueWorktreeRegistration = async (registeredWorktree) => {
+        closeWorktreeCreator(true);
+        if (createSessionCallback === undefined) {
+            await refresh({ preserveCurrent: true });
+            setActionError({
+                code: 'WORKTREE_REGISTRATION_SESSION_UNAVAILABLE',
+                message: '',
+                retryable: true,
+            });
             return;
         }
-        const input = {
-            workspaceId: modalWorkspace.workspaceId,
-            branch: selectedBranch,
-            newBranch: worktreeName,
+        const sessionInput = {
+            workspaceId: registeredWorktree.workspaceId,
+            worktreeId: registeredWorktree.worktreeId,
+            cwd: registeredWorktree.absolutePath,
         };
+        try {
+            await createSessionCallback(sessionInput);
+            await invalidateWorktreeContext?.(registeredWorktree.workspaceId);
+        }
+        catch (error) {
+            if (error instanceof WorktreeSessionBindingError && error.retryable) {
+                setPendingSessionBinding({ ...sessionInput, sessionId: error.sessionId });
+            }
+            throw error;
+        }
+        await refresh({ preserveCurrent: true });
+    };
+    const submitWorktree = async () => {
+        const worktreeName = newBranch.trim();
+        const selectedImportCandidate = importCandidates.candidates.find((candidate) => candidate.absolutePath === selectedImportPath);
+        if (manager === undefined || modalWorkspace === undefined)
+            return;
+        if (worktreeModalMode === 'create' &&
+            (!modalCanCreate || selectedBranch.length === 0 || worktreeName.length === 0))
+            return;
+        if (worktreeModalMode === 'import' && selectedImportCandidate === undefined)
+            return;
         setActionPending(true);
         setActionError(undefined);
         setPendingSessionBinding(undefined);
         try {
-            const createdWorktree = await executeWorktreeAction(manager, {
-                type: 'createWorktree',
-                input,
-            });
-            if (createdWorktree === undefined) {
+            const registeredWorktree = worktreeModalMode === 'create'
+                ? await executeWorktreeAction(manager, {
+                    type: 'createWorktree',
+                    input: {
+                        workspaceId: modalWorkspace.workspaceId,
+                        branch: selectedBranch,
+                        newBranch: worktreeName,
+                    },
+                })
+                : await executeWorktreeAction(manager, {
+                    type: 'importWorktree',
+                    input: {
+                        workspaceId: modalWorkspace.workspaceId,
+                        absolutePath: selectedImportCandidate.absolutePath,
+                    },
+                });
+            if (registeredWorktree === undefined) {
                 throw {
                     code: 'WORKTREE_RECORD_MISSING',
                     message: '',
                     retryable: true,
                 };
             }
-            setWorktreeModalWorkspaceId(undefined);
-            if (createSessionCallback === undefined) {
-                await refresh({ preserveCurrent: true });
-                setActionError({
-                    code: 'WORKTREE_CREATED_SESSION_UNAVAILABLE',
-                    message: '',
-                    retryable: true,
-                });
-                return;
-            }
-            const sessionInput = {
-                workspaceId: createdWorktree.workspaceId,
-                worktreeId: createdWorktree.worktreeId,
-                cwd: createdWorktree.absolutePath,
-            };
-            try {
-                await createSessionCallback(sessionInput);
-                await invalidateWorktreeContext?.(createdWorktree.workspaceId);
-            }
-            catch (error) {
-                if (error instanceof WorktreeSessionBindingError && error.retryable) {
-                    setPendingSessionBinding({ ...sessionInput, sessionId: error.sessionId });
-                }
-                throw error;
-            }
-            await refresh({ preserveCurrent: true });
+            await continueWorktreeRegistration(registeredWorktree);
         }
         catch (error) {
             setActionError(toWorktreeViewError(error));
@@ -562,15 +811,21 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                     const mainLabel = currentBranch === undefined
                                         ? t('worktree.main')
                                         : t('worktree.mainWithBranch', { branch: currentBranch });
-                                    const expanded = expandedWorkspaces[workspace.workspaceId] !== false;
+                                    const expanded = isWorkspaceExpanded(expandSnapshot, workspace.workspaceId) ||
+                                        isCurrentSessionReveal('workspace:' + workspace.workspaceId);
                                     const workspaceMatchesQuery = includesText(workspace.title, query);
                                     const allWorkspaceSessionIds = filterArchivedSessionIds(workspaceSessionIds(workspaces, workspace.workspaceId, sessions.ids), archivedSessionIds);
                                     const bindings = view?.bindings ?? [];
                                     const boundSessionIds = new Set(bindings.map((binding) => binding.sessionId));
                                     const mainSessionIds = filterVisibleSessionIds(unboundSessionIds(allWorkspaceSessionIds, [...boundSessionIds]), sessions);
                                     const visibleMainSessionIds = mainSessionIds.filter((sessionId) => workspaceMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
-                                    const mainExpanded = expandedMains[workspace.workspaceId] !== false;
+                                    const mainExpanded = isMainExpanded(expandSnapshot, workspace.workspaceId) ||
+                                        isCurrentSessionReveal('main:' + workspace.workspaceId);
                                     const mainGroupKey = `main:${workspace.workspaceId}`;
+                                    const sessionIds = visibleMainSessionIds;
+                                    const mainSessionGroupExpanded = expandedSessionGroups[mainGroupKey] === true ||
+                                        (sessionIds.length > 5 &&
+                                            isCurrentSessionReveal('session-group:' + mainGroupKey));
                                     const worktrees = view?.worktrees ?? [];
                                     const sameWorkspaceWorktreeDrag = worktreeDrag?.workspaceId === workspace.workspaceId;
                                     return (_jsxs("section", { className: styles.workspaceGroup, "data-workspace-id": workspace.workspaceId, children: [_jsx(WorktreeWorkspaceRow, { t: t, workspace: workspace, expanded: expanded, actionPending: actionPending, menuOpen: openWorkspaceMenuId === workspace.workspaceId, drag: {
@@ -623,11 +878,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                             ? undefined
                                                             : () => {
                                                                 createMainSession(workspace.workspaceId);
-                                                            } }), mainExpanded && (_jsx(WorktreeSessionGroup, { t: t, groupKey: mainGroupKey, sessionIds: visibleMainSessionIds, workspaceId: workspace.workspaceId, expanded: expandedSessionGroups[mainGroupKey] === true, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
-                                                            setExpandedSessionGroups((current) => ({
-                                                                ...current,
-                                                                [mainGroupKey]: current[mainGroupKey] !== true,
-                                                            }));
+                                                            } }), mainExpanded && (_jsx(WorktreeSessionGroup, { t: t, groupKey: mainGroupKey, sessionIds: sessionIds, workspaceId: workspace.workspaceId, currentSessionId: currentSessionId, expanded: mainSessionGroupExpanded, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
+                                                            toggleSessionGroup(mainGroupKey);
                                                         }, onStartDrag: (groupKey, sessionId) => {
                                                             sessionDropCommitted.current = false;
                                                             setSessionDrag({ groupKey, sessionId, over: null });
@@ -653,6 +905,10 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                         }
                                                         const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
                                                         const worktreeGroupKey = `worktree:${record.worktreeId}`;
+                                                        const sessionIds = visibleWorktreeSessionIds;
+                                                        const sessionGroupExpanded = expandedSessionGroups[worktreeGroupKey] === true ||
+                                                            (sessionIds.length > 5 &&
+                                                                isCurrentSessionReveal('session-group:' + worktreeGroupKey));
                                                         const state = record.status === 'removed'
                                                             ? 'warning'
                                                             : record.health === 'repair'
@@ -663,7 +919,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                             : record.health === 'repair'
                                                                 ? t('worktree.repair')
                                                                 : t('worktree.ready');
-                                                        const worktreeExpanded = expandedWorktrees[record.worktreeId] !== false;
+                                                        const worktreeExpanded = isWorktreeExpanded(expandSnapshot, record.worktreeId) ||
+                                                            isCurrentSessionReveal('worktree:' + record.worktreeId);
                                                         return (_jsxs("div", { className: styles.worktreeGroup, "data-worktree-id": record.worktreeId, children: [_jsx(WorktreeGroupRow, { t: t, kind: "worktree", label: record.branch, worktreeId: record.worktreeId, expanded: worktreeExpanded, icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, state: state, stateLabel: stateLabel, onToggle: () => {
                                                                         toggleWorktree(record.worktreeId);
                                                                     }, onCreateSession: record.status === 'active' && record.health !== 'repair'
@@ -718,11 +975,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                             setWorktreeDrag(undefined);
                                                                             worktreeDropCommitted.current = false;
                                                                         },
-                                                                    } }), worktreeExpanded && (_jsx(WorktreeSessionGroup, { t: t, groupKey: worktreeGroupKey, sessionIds: visibleWorktreeSessionIds, workspaceId: workspace.workspaceId, expanded: expandedSessionGroups[worktreeGroupKey] === true, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
-                                                                        setExpandedSessionGroups((current) => ({
-                                                                            ...current,
-                                                                            [worktreeGroupKey]: current[worktreeGroupKey] !== true,
-                                                                        }));
+                                                                    } }), worktreeExpanded && (_jsx(WorktreeSessionGroup, { t: t, groupKey: worktreeGroupKey, sessionIds: sessionIds, workspaceId: workspace.workspaceId, currentSessionId: currentSessionId, expanded: sessionGroupExpanded, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
+                                                                        toggleSessionGroup(worktreeGroupKey);
                                                                     }, onStartDrag: (groupKey, sessionId) => {
                                                                         sessionDropCommitted.current = false;
                                                                         setSessionDrag({ groupKey, sessionId, over: null });
@@ -740,17 +994,24 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                         ? undefined
                                                                         : archiveWorktreeSession }))] }, record.worktreeId));
                                                     })] }))] }, workspace.workspaceId));
-                                })) })) : null] })] }), _jsx("div", { className: styles.railContent, children: _jsx("button", { type: "button", className: styles.railButton, "aria-label": t('mode.exit'), onClick: () => {
-                        actions.setViewMode('workspace-session');
-                    }, children: "WT" }) }), _jsx(WorktreeSessionRenameDialog, { t: t, target: sessionRenameTarget, draft: sessionRenameDraft, pending: sessionRenamePending, error: sessionRenameError, onClose: closeSessionRename, onDraftChange: (draft) => {
+                                })) })) : null] })] }), _jsx(WorktreeSessionRenameDialog, { t: t, target: sessionRenameTarget, draft: sessionRenameDraft, pending: sessionRenamePending, error: sessionRenameError, onClose: closeSessionRename, onDraftChange: (draft) => {
                     setSessionRenameDraft(draft);
                     setSessionRenameError(undefined);
                 }, onSubmit: confirmSessionRename }), _jsx(WorktreeWorkspaceRenameDialog, { t: t, target: workspaceRenameTarget, draft: workspaceRenameDraft, pending: workspaceRenamePending, duplicate: workspaceRenameDuplicate, error: workspaceRenameError, onClose: closeWorkspaceRename, onDraftChange: (draft) => {
                     setWorkspaceRenameDraft(draft);
                     setWorkspaceRenameError(undefined);
-                }, onSubmit: confirmWorkspaceRename }), _jsx(WorktreeWorkspaceDeleteDialog, { t: t, target: workspaceDeleteTarget, pending: workspaceDeletePending, error: workspaceDeleteError, onClose: closeWorkspaceDelete, onSubmit: confirmWorkspaceDelete }), _jsx(WorktreeCreateDialog, { t: t, workspace: modalWorkspace, view: modalView, setupStatus: modalSetupStatus, canCreate: modalCanCreate, selectedBranch: selectedBranch, newBranch: newBranch, actionPending: actionPending, onClose: () => {
-                    setWorktreeModalWorkspaceId(undefined);
-                }, onSelectedBranchChange: setSelectedBranch, onNewBranchChange: setNewBranch, onSubmit: submitWorktree }), _jsx(WorktreeRemovalDialog, { t: t, worktree: worktreeRemoval, actionPending: actionPending, onClose: () => {
+                }, onSubmit: confirmWorkspaceRename }), _jsx(WorktreeWorkspaceDeleteDialog, { t: t, target: workspaceDeleteTarget, pending: workspaceDeletePending, error: workspaceDeleteError, onClose: closeWorkspaceDelete, onSubmit: confirmWorkspaceDelete }), _jsx(WorktreeCreateDialog, { t: t, workspace: modalWorkspace, view: modalView, readError: modalReadError, setupStatus: modalSetupStatus, canCreate: modalCanCreate, mode: worktreeModalMode, importCandidates: importCandidates, selectedImportPath: selectedImportPath, selectedBranch: selectedBranch, newBranch: newBranch, actionPending: actionPending, onClose: closeWorktreeCreator, onRetry: () => {
+                    if (worktreeModalWorkspaceId === undefined)
+                        return;
+                    modalReadViewRef.current = undefined;
+                    setSelectedBranch('');
+                    setNewBranch('');
+                    loadModalWorktreeView(worktreeModalWorkspaceId);
+                }, onModeChange: changeWorktreeModalMode, onRetryImportCandidates: () => {
+                    if (worktreeModalWorkspaceId !== undefined) {
+                        void loadImportCandidates(worktreeModalWorkspaceId);
+                    }
+                }, onSelectedImportPathChange: setSelectedImportPath, onSelectedBranchChange: setSelectedBranch, onNewBranchChange: setNewBranch, onSubmit: submitWorktree }), _jsx(WorktreeRemovalDialog, { t: t, worktree: worktreeRemoval, actionPending: actionPending, onClose: () => {
                     setWorktreeRemoval(undefined);
                 }, onSubmit: () => {
                     if (manager === undefined || worktreeRemoval === undefined)