@cerbur/clutch-dsh-worktree 0.1.5 → 0.1.7

package/lib/client/WorktreeSurface.js

@@ -1,16 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { IconBranchOutline16, IconCloseOutline16, IconPlusOutline16, IconSearchOutline16, } from '@deepseek-ai/dsh-client-ui-primitives';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
+import { IconBranchOutline16, IconCloseOutline16, IconProjectAddOutline16, IconSearchOutline16, RiskConfirmation, } 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 { formatWorktreePermissionNotice, formatWorktreeViewError, } from './worktree-error-copy.js';
+import { deriveSessionPresentationIndex, filterVisibleSessionIds, hasOngoingSession, sessionMatchesQuery, } from './session-view.js';
+import { nextSessionOrderAccount, reorderSessionIds, } from './worktree-session-order.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, isSessionGroupAutoExpanded, 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, createNumberedWorktreeName, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, loadWorktreeViews, mergeWorktreeView, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, WorktreeSessionPermissionError, } from './worktree-view.js';
 import styles from './worktree.css';
 function toNativeWorktreeViewError(error) {
     const viewError = toWorktreeViewError(error);
@@ -19,6 +22,30 @@ function toNativeWorktreeViewError(error) {
     return { ...viewError, message: String(error) };
 }
 const EMPTY_READ_STATE = { status: 'idle', views: [] };
+const EMPTY_PERMISSION_NOTICE = undefined;
+const EMPTY_PERMISSION_NOTICE_SUBSCRIBE = () => () => { };
+const EMPTY_PERMISSION_NOTICE_SNAPSHOT = () => EMPTY_PERMISSION_NOTICE;
+const EMPTY_FULL_ACCESS_CONFIRMATION_SUBSCRIBE = () => () => { };
+const EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT = () => undefined;
+const EMPTY_FORK_RECOVERY_SNAPSHOT = { revision: 0, pending: [] };
+const EMPTY_FORK_RECOVERY_STORE = {
+    getSnapshot: () => EMPTY_FORK_RECOVERY_SNAPSHOT,
+    subscribe: () => () => { },
+};
+function updatedAtById(sessionIds, sessions) {
+    return Object.fromEntries(sessionIds.map((sessionId) => [sessionId, sessions.byId[sessionId]?.updatedAt]));
+}
+function forkRecoveryError(recovery) {
+    const error = toNativeWorktreeViewError(recovery.error);
+    return {
+        ...error,
+        code: error.code === 'WORKTREE_VIEW_FAILED' ? 'SESSION_BINDING_FAILED' : error.code,
+        details: {
+            ...(error.details ?? {}),
+            sessionId: recovery.childSessionId,
+        },
+    };
+}
 function useStableWorkspaceIds(workspaces) {
     const next = workspaces.map((workspace) => workspace.workspaceId);
     const previousRef = useRef([]);
@@ -31,21 +58,52 @@ 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, sessionOrder, manager, permission, confirmFullAccess, fullAccessConfirmation, onPermissionResult, onPermissionNotice, permissionNotice, invalidateWorktreeContext, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, insertWorktreeBefore, renameSession, forkSession, archiveSession, forkRecovery, retryForkSession, 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 forkRecoveryStore = forkRecovery ?? EMPTY_FORK_RECOVERY_STORE;
+    const forkRecoverySnapshot = useSyncExternalStore(forkRecoveryStore.subscribe, forkRecoveryStore.getSnapshot, forkRecoveryStore.getSnapshot);
+    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 permissionNoticeSnapshot = useSyncExternalStore(permissionNotice?.subscribe ?? EMPTY_PERMISSION_NOTICE_SUBSCRIBE, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT);
+    const fullAccessConfirmationSnapshot = useSyncExternalStore(fullAccessConfirmation?.subscribe ?? EMPTY_FULL_ACCESS_CONFIRMATION_SUBSCRIBE, fullAccessConfirmation?.getSnapshot ?? EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT, fullAccessConfirmation?.getSnapshot ?? EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT);
+    const fullAccessConfirmationKey = fullAccessConfirmationSnapshot === undefined
+        ? ''
+        : [
+            fullAccessConfirmationSnapshot.workspaceId,
+            fullAccessConfirmationSnapshot.worktreeId,
+            fullAccessConfirmationSnapshot.sessionId,
+            fullAccessConfirmationSnapshot.cwd,
+        ].join('\u0000');
+    const [fullAccessAcknowledged, setFullAccessAcknowledged] = useState(false);
+    useEffect(() => {
+        setFullAccessAcknowledged(false);
+    }, [fullAccessConfirmationKey]);
+    const sessionOrderSnapshot = useSyncExternalStore(sessionOrder.subscribe, sessionOrder.getSnapshot, sessionOrder.getSnapshot);
+    const sessionPresentations = useMemo(() => deriveSessionPresentationIndex(sessions), [sessions.byId]);
     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 [openMainMenuId, setOpenMainMenuId] = useState();
     const [openWorktreeMenuId, setOpenWorktreeMenuId] = useState();
     const [worktreeRemoval, setWorktreeRemoval] = useState();
     const [selectedBranch, setSelectedBranch] = useState('');
@@ -53,6 +111,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [pendingSessionBinding, setPendingSessionBinding] = useState();
     const [actionError, setActionError] = useState();
     const [actionPending, setActionPending] = useState(false);
+    const [forkRetryKey, setForkRetryKey] = useState();
     const [sessionRenameTarget, setSessionRenameTarget] = useState();
     const [sessionRenameDraft, setSessionRenameDraft] = useState('');
     const [sessionRenamePending, setSessionRenamePending] = useState(false);
@@ -72,6 +131,12 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [worktreeDrag, setWorktreeDrag] = useState();
     const worktreeDropCommitted = useRef(false);
     const refreshGuard = useRef(createWorktreeRefreshGuard());
+    const forkRecoveryRevisionRef = useRef(forkRecoverySnapshot.revision);
+    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,26 +157,73 @@ 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]);
+    useEffect(() => {
+        if (forkRecoveryRevisionRef.current === forkRecoverySnapshot.revision)
+            return;
+        forkRecoveryRevisionRef.current = forkRecoverySnapshot.revision;
+        if (mode !== 'worktree' || manager === undefined)
+            return;
+        void refresh({
+            preserveCurrent: readStateRef.current.status === 'ready',
+            invalidateContext: false,
+        }).catch(() => {
+            // Recovery state remains visible; the next explicit retry can refresh it again.
+        });
+    }, [forkRecoverySnapshot.revision, manager, mode, refresh]);
     useEffect(() => {
         if (readState.status !== 'ready' || syncSessionWorkspaces === undefined)
             return;
@@ -121,6 +233,117 @@ 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 sessionOrderInputs = useMemo(() => {
+        if (readState.status !== 'ready')
+            return [];
+        const inputs = [];
+        for (const workspace of workspaces.items) {
+            const view = viewByWorkspace.get(workspace.workspaceId);
+            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);
+            inputs.push({
+                accountKey: `main:${workspace.workspaceId}`,
+                sessionIds: mainSessionIds,
+                updatedAtById: updatedAtById(mainSessionIds, sessions),
+            });
+            for (const record of view?.worktrees ?? []) {
+                const worktreeSessionIds = filterVisibleSessionIds(filterArchivedSessionIds(bindingIdsFor(bindings, record.worktreeId).filter((sessionId) => sessions.ids.includes(sessionId)), archivedSessionIds), sessions);
+                inputs.push({
+                    accountKey: `worktree:${record.worktreeId}`,
+                    sessionIds: worktreeSessionIds,
+                    updatedAtById: updatedAtById(worktreeSessionIds, sessions),
+                });
+            }
+        }
+        return inputs;
+    }, [
+        archivedSessionIds,
+        readState.status,
+        sessions.byId,
+        sessions.ids,
+        viewByWorkspace,
+        workspaces,
+        workspaces.items,
+    ]);
+    const orderedSessionIdsByAccount = useMemo(() => {
+        const ordered = new Map();
+        for (const input of sessionOrderInputs) {
+            const previous = sessionOrderSnapshot.accounts[input.accountKey];
+            ordered.set(input.accountKey, nextSessionOrderAccount({
+                baseIds: input.sessionIds,
+                updatedAtById: input.updatedAtById,
+                previous,
+            }).order);
+        }
+        return ordered;
+    }, [sessionOrderInputs, sessionOrderSnapshot]);
+    useEffect(() => {
+        if (mode !== 'worktree' || readState.status !== 'ready')
+            return;
+        for (const input of sessionOrderInputs) {
+            sessionOrder.actions.reconcile(input.accountKey, input.sessionIds, input.updatedAtById);
+        }
+        sessionOrder.actions.retain(sessionOrderInputs.map((input) => input.accountKey));
+    }, [mode, readState.status, sessionOrder, sessionOrderInputs]);
+    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
@@ -129,17 +352,29 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const modalSetupStatus = modalView === undefined
         ? undefined
         : modalReadiness?.status === 'ready'
-            ? modalView.branches.length === 0 ? 'noLocalBranch' : undefined
+            ? 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 +390,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 &&
@@ -249,9 +502,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         const sourceIndex = rows.findIndex((workspace) => workspace.workspaceId === activeDrag.workspaceId);
         if (targetIndex === -1 || sourceIndex === -1)
             return;
-        const beforeWorkspaceId = over.half === 'before'
-            ? over.workspaceId
-            : rows[targetIndex + 1]?.workspaceId;
+        const beforeWorkspaceId = over.half === 'before' ? over.workspaceId : rows[targetIndex + 1]?.workspaceId;
         const anchorIndex = beforeWorkspaceId === undefined
             ? rows.length
             : rows.findIndex((workspace) => workspace.workspaceId === beforeWorkspaceId);
@@ -282,12 +533,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         const sourceIndex = sessionIds.indexOf(activeDrag.sessionId);
         if (targetIndex === -1 || sourceIndex === -1)
             return;
-        const beforeSessionId = over.half === 'before'
-            ? over.sessionId
-            : sessionIds[targetIndex + 1];
-        const anchorIndex = beforeSessionId === undefined
-            ? sessionIds.length
-            : sessionIds.indexOf(beforeSessionId);
+        const beforeSessionId = over.half === 'before' ? over.sessionId : sessionIds[targetIndex + 1];
+        const anchorIndex = beforeSessionId === undefined ? sessionIds.length : sessionIds.indexOf(beforeSessionId);
         if (beforeSessionId === activeDrag.sessionId ||
             anchorIndex === sourceIndex ||
             anchorIndex === sourceIndex + 1) {
@@ -302,7 +549,12 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             return;
         }
         setActionError(undefined);
-        void insertSessionBefore(workspaceId, activeDrag.sessionId, beforeSessionId).catch((error) => {
+        const currentOrder = sessionOrderSnapshot.accounts[activeDrag.groupKey]?.order ?? sessionIds;
+        void insertSessionBefore(workspaceId, activeDrag.sessionId, beforeSessionId)
+            .then(() => {
+            sessionOrder.actions.setOrder(activeDrag.groupKey, reorderSessionIds(currentOrder, activeDrag.sessionId, over.sessionId, over.half));
+        })
+            .catch((error) => {
             setActionError(toWorktreeViewError(error));
         });
     };
@@ -373,91 +625,207 @@ 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, autoExpanded) => {
+        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 openWorktreeCreator = (workspace) => {
+    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, defaults = {}) => {
         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(defaults.baseBranch ?? '');
+            setNewBranch(defaults.newBranch ?? '');
+            loadModalWorktreeView(workspace.workspaceId);
+            return;
+        }
+        setSelectedBranch(defaults.baseBranch ?? selectDefaultBaseBranch(view.branches));
+        setNewBranch(defaults.newBranch ?? 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 });
+            }
+            if (error instanceof WorktreeSessionPermissionError && error.retryable) {
+                setPendingSessionBinding({
+                    ...sessionInput,
+                    sessionId: error.sessionId,
+                    permissionRequired: true,
+                });
+            }
+            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));
@@ -487,6 +855,13 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             if (error instanceof WorktreeSessionBindingError && error.retryable) {
                 setPendingSessionBinding({ ...input, sessionId: error.sessionId });
             }
+            if (error instanceof WorktreeSessionPermissionError && error.retryable) {
+                setPendingSessionBinding({
+                    ...input,
+                    sessionId: error.sessionId,
+                    permissionRequired: true,
+                });
+            }
             setActionError(toWorktreeViewError(error));
         }
         finally {
@@ -494,9 +869,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         }
     };
     const retrySessionBinding = async () => {
-        if (manager === undefined ||
-            pendingSessionBinding === undefined ||
-            pendingSessionArchived)
+        if (manager === undefined || pendingSessionBinding === undefined || pendingSessionArchived)
             return;
         const pending = pendingSessionBinding;
         setActionPending(true);
@@ -509,6 +882,9 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                 ensureSessionWorkspace: (workspaceId, sessionId) => {
                     ensureSessionWorkspace?.(workspaceId, sessionId);
                 },
+                permission,
+                confirmFullAccess,
+                onPermissionResult,
                 openSession,
             });
             setPendingSessionBinding(undefined);
@@ -525,6 +901,20 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             setActionPending(false);
         }
     };
+    const retryForkBinding = async (key) => {
+        if (retryForkSession === undefined || forkRetryKey !== undefined)
+            return;
+        setForkRetryKey(key);
+        try {
+            await retryForkSession(key);
+        }
+        catch (error) {
+            setActionError(toNativeWorktreeViewError(error));
+        }
+        finally {
+            setForkRetryKey(undefined);
+        }
+    };
     const openWorkspaceSession = (workspaceId, sessionId) => {
         ensureSessionWorkspace?.(workspaceId, sessionId);
         openWorktreeSession({ open: openSession }, sessionId);
@@ -544,14 +934,21 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                 } }), _jsx("button", { type: "button", className: styles.iconButton, "aria-label": t('workspace.add'), onClick: () => {
                                     if (createWorkspace !== undefined)
                                         void runMutation(createWorkspace);
-                                }, children: _jsx(IconPlusOutline16, {}) })] }), _jsxs("div", { className: styles.content, tabIndex: 0, children: [actionError !== undefined && (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(actionError, t) }), pendingSessionBinding !== undefined && (_jsxs("div", { className: styles.recoveryActions, children: [_jsx("button", { type: "button", className: styles.actionButton, disabled: actionPending || pendingSessionArchived, onClick: () => {
+                                }, children: _jsx(IconProjectAddOutline16, {}) })] }), _jsxs("div", { className: styles.content, tabIndex: 0, children: [permissionNoticeSnapshot !== undefined && (_jsx("div", { className: styles.notice, role: "status", "data-worktree-permission-notice": true, children: _jsx("p", { className: styles.message, children: formatWorktreePermissionNotice(permissionNoticeSnapshot.result, t) }) })), forkRecoverySnapshot.pending.map((recovery) => {
+                                const recoveryViewError = forkRecoveryError(recovery);
+                                return (_jsxs("div", { className: styles.error, role: "alert", "data-fork-recovery": recovery.key, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(recoveryViewError, t) }), _jsxs("div", { className: styles.recoveryActions, children: [retryForkSession !== undefined && recoveryViewError.retryable && (_jsx("button", { type: "button", className: styles.actionButton, disabled: forkRetryKey !== undefined, onClick: () => {
+                                                        void retryForkBinding(recovery.key);
+                                                    }, children: t('action.retryBinding') })), _jsx("button", { type: "button", className: styles.actionButton, disabled: forkRetryKey !== undefined, onClick: () => {
+                                                        openSession(recovery.childSessionId);
+                                                    }, children: t('action.openCreatedSession') })] })] }, recovery.key));
+                            }), actionError !== undefined && (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(actionError, t) }), pendingSessionBinding !== undefined && (_jsxs("div", { className: styles.recoveryActions, children: [_jsx("button", { type: "button", className: styles.actionButton, disabled: actionPending || pendingSessionArchived, onClick: () => {
                                                     void retrySessionBinding();
-                                                }, children: t('action.retryBinding') }), _jsx("button", { type: "button", className: styles.actionButton, disabled: actionPending, onClick: () => {
+                                                }, children: t('action.retryBinding') }), !pendingSessionBinding.permissionRequired && (_jsx("button", { type: "button", className: styles.actionButton, disabled: actionPending, onClick: () => {
                                                     const sessionId = pendingSessionBinding.sessionId;
                                                     setPendingSessionBinding(undefined);
                                                     setActionError(undefined);
                                                     openSession(sessionId);
-                                                }, children: t('action.openCreatedSession') })] })), actionError.retryable && (_jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
+                                                }, children: t('action.openCreatedSession') }))] })), actionError.retryable && (_jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
                                             setActionError(undefined);
                                             void refresh();
                                         }, children: t('action.retry') }))] })), readState.status === 'loading' && (_jsx("p", { className: styles.message, children: t('status.loading') })), readState.status === 'error' && readState.error !== undefined ? (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(readState.error, t) }), _jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
@@ -562,18 +959,34 @@ 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 workspaceActivitySessionIds = filterVisibleSessionIds(allWorkspaceSessionIds, sessions);
+                                    const workspaceHasOngoingSession = hasOngoingSession(workspaceActivitySessionIds, sessionPresentations);
                                     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 mainGroupKey = `main:${workspace.workspaceId}`;
+                                    const orderedMainSessionIds = orderedSessionIdsByAccount.get(mainGroupKey) ?? mainSessionIds;
+                                    const visibleMainSessionIds = mainSessionIds.filter((sessionId) => workspaceMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
+                                    const orderedVisibleMainSessionIds = orderedMainSessionIds.filter((sessionId) => workspaceMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
+                                    const mainExpanded = isMainExpanded(expandSnapshot, workspace.workspaceId) ||
+                                        isCurrentSessionReveal('main:' + workspace.workspaceId);
+                                    const sessionIds = orderedVisibleMainSessionIds.length === visibleMainSessionIds.length
+                                        ? orderedVisibleMainSessionIds
+                                        : visibleMainSessionIds;
+                                    const mainSessionGroupAutoExpanded = isSessionGroupAutoExpanded(sessionIds, currentSessionId, isCurrentSessionReveal('session-group:' + mainGroupKey));
+                                    const mainSessionGroupExpanded = expandedSessionGroups[mainGroupKey] === true ||
+                                        mainSessionGroupAutoExpanded;
                                     const worktrees = view?.worktrees ?? [];
+                                    const workspaceWorktreeNames = [
+                                        ...(view?.branches.map((branch) => branch.name) ?? []),
+                                        ...(view?.worktrees.map((worktree) => worktree.branch) ?? []),
+                                    ];
                                     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: {
+                                    return (_jsxs("section", { className: styles.workspaceGroup, "data-workspace-id": workspace.workspaceId, children: [_jsx(WorktreeWorkspaceRow, { t: t, workspace: workspace, expanded: expanded, hasOngoingSession: workspaceHasOngoingSession, actionPending: actionPending, menuOpen: openWorkspaceMenuId === workspace.workspaceId, drag: {
                                                     active: workspaceDrag !== undefined,
                                                     marker: workspaceDrag?.over?.workspaceId === workspace.workspaceId
                                                         ? workspaceDrag.over.half
@@ -617,17 +1030,32 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                     openWorkspaceDelete(workspace);
                                                 }, onMenuOpenChange: (open) => {
                                                     setOpenWorkspaceMenuId(open ? workspace.workspaceId : undefined);
-                                                } }), expanded && (_jsxs("div", { className: styles.treeChildren, children: [_jsx(WorktreeGroupRow, { t: t, kind: "main", label: mainLabel, expanded: mainExpanded, icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, onToggle: () => {
+                                                } }), expanded && (_jsxs("div", { className: styles.treeChildren, children: [_jsx(WorktreeGroupRow, { t: t, kind: "main", label: mainLabel, expanded: mainExpanded, hasOngoingSession: hasOngoingSession(mainSessionIds, sessionPresentations), icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, onToggle: () => {
                                                             toggleMain(workspace.workspaceId);
+                                                        }, menu: {
+                                                            open: openMainMenuId === workspace.workspaceId,
+                                                            label: mainLabel,
+                                                            copyPath: workspace.path,
+                                                            showCreate: currentBranch !== undefined,
+                                                            showRemove: false,
+                                                            disabled: actionPending,
+                                                            onOpenChange: (open) => {
+                                                                setOpenMainMenuId(open ? workspace.workspaceId : undefined);
+                                                            },
+                                                            onCreateWorktree: currentBranch === undefined
+                                                                ? undefined
+                                                                : () => {
+                                                                    openWorktreeCreator(workspace, {
+                                                                        baseBranch: currentBranch,
+                                                                        newBranch: createNumberedWorktreeName(currentBranch, workspaceWorktreeNames),
+                                                                    });
+                                                                },
                                                         }, onCreateSession: createMainSession === undefined
                                                             ? 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, sessionPresentations: sessionPresentations, dragState: sessionDrag, onToggleExpanded: () => {
+                                                            toggleSessionGroup(mainGroupKey, mainSessionGroupAutoExpanded);
                                                         }, onStartDrag: (groupKey, sessionId) => {
                                                             sessionDropCommitted.current = false;
                                                             setSessionDrag({ groupKey, sessionId, over: null });
@@ -651,8 +1079,20 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                             !worktreeSessionIds.some((sessionId) => sessionMatchesQuery(sessionId, sessions, query))) {
                                                             return null;
                                                         }
-                                                        const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
+                                                        const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery ||
+                                                            sessionMatchesQuery(sessionId, sessions, query));
                                                         const worktreeGroupKey = `worktree:${record.worktreeId}`;
+                                                        const orderedWorktreeSessionIds = orderedSessionIdsByAccount.get(worktreeGroupKey) ??
+                                                            worktreeSessionIds;
+                                                        const orderedVisibleWorktreeSessionIds = orderedWorktreeSessionIds.filter((sessionId) => worktreeMatchesQuery ||
+                                                            sessionMatchesQuery(sessionId, sessions, query));
+                                                        const sessionIds = orderedVisibleWorktreeSessionIds.length ===
+                                                            visibleWorktreeSessionIds.length
+                                                            ? orderedVisibleWorktreeSessionIds
+                                                            : visibleWorktreeSessionIds;
+                                                        const sessionGroupAutoExpanded = isSessionGroupAutoExpanded(sessionIds, currentSessionId, isCurrentSessionReveal('session-group:' + worktreeGroupKey));
+                                                        const sessionGroupExpanded = expandedSessionGroups[worktreeGroupKey] === true ||
+                                                            sessionGroupAutoExpanded;
                                                         const state = record.status === 'removed'
                                                             ? 'warning'
                                                             : record.health === 'repair'
@@ -663,8 +1103,9 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                             : record.health === 'repair'
                                                                 ? t('worktree.repair')
                                                                 : t('worktree.ready');
-                                                        const worktreeExpanded = expandedWorktrees[record.worktreeId] !== false;
-                                                        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: () => {
+                                                        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, hasOngoingSession: hasOngoingSession(worktreeSessionIds, sessionPresentations), icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, state: state, stateLabel: stateLabel, onToggle: () => {
                                                                         toggleWorktree(record.worktreeId);
                                                                     }, onCreateSession: record.status === 'active' && record.health !== 'repair'
                                                                         ? () => {
@@ -674,20 +1115,31 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                                 cwd: record.absolutePath,
                                                                             });
                                                                         }
-                                                                        : undefined, menu: record.status === 'active'
-                                                                        ? {
-                                                                            open: openWorktreeMenuId === record.worktreeId,
-                                                                            label: record.branch,
-                                                                            disabled: actionPending,
-                                                                            onOpenChange: (open) => {
-                                                                                setOpenWorktreeMenuId(open ? record.worktreeId : undefined);
-                                                                            },
-                                                                            onRemove: () => {
+                                                                        : undefined, menu: {
+                                                                        open: openWorktreeMenuId === record.worktreeId,
+                                                                        label: record.branch,
+                                                                        copyPath: record.absolutePath,
+                                                                        showCreate: record.status === 'active',
+                                                                        showRemove: record.status === 'active',
+                                                                        disabled: actionPending,
+                                                                        onOpenChange: (open) => {
+                                                                            setOpenWorktreeMenuId(open ? record.worktreeId : undefined);
+                                                                        },
+                                                                        onCreateWorktree: record.status === 'active'
+                                                                            ? () => {
+                                                                                openWorktreeCreator(workspace, {
+                                                                                    baseBranch: record.branch,
+                                                                                    newBranch: createNumberedWorktreeName(record.branch, workspaceWorktreeNames),
+                                                                                });
+                                                                            }
+                                                                            : undefined,
+                                                                        onRemove: record.status === 'active'
+                                                                            ? () => {
                                                                                 setWorktreeRemoval(record);
                                                                                 setActionError(undefined);
-                                                                            },
-                                                                        }
-                                                                        : undefined, drag: {
+                                                                            }
+                                                                            : undefined,
+                                                                    }, drag: {
                                                                         active: sameWorkspaceWorktreeDrag,
                                                                         marker: worktreeDrag?.over?.worktreeId === record.worktreeId
                                                                             ? worktreeDrag.over.half
@@ -718,11 +1170,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, sessionPresentations: sessionPresentations, dragState: sessionDrag, onToggleExpanded: () => {
+                                                                        toggleSessionGroup(worktreeGroupKey, sessionGroupAutoExpanded);
                                                                     }, onStartDrag: (groupKey, sessionId) => {
                                                                         sessionDropCommitted.current = false;
                                                                         setSessionDrag({ groupKey, sessionId, over: null });
@@ -746,9 +1195,18 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                 }, 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)
@@ -761,10 +1219,20 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                 workspaceId: target.workspaceId,
                                 worktreeId: target.worktreeId,
                             },
-                        });
+                        }, permission, onPermissionNotice);
                         await invalidateWorktreeContext?.(target.workspaceId);
                         setWorktreeRemoval(undefined);
                     });
+                } }), _jsx(RiskConfirmation, { open: fullAccessConfirmationSnapshot !== undefined, title: t('permission.fullAccessTitle'), description: fullAccessConfirmationSnapshot === undefined
+                    ? ''
+                    : t('permission.fullAccessDescription', {
+                        cwd: fullAccessConfirmationSnapshot.cwd,
+                    }), acknowledgeLabel: t('permission.fullAccessAcknowledge'), cancelLabel: t('dialog.cancel'), confirmLabel: t('permission.fullAccessEnable'), acknowledged: fullAccessAcknowledged, onAcknowledgedChange: setFullAccessAcknowledged, onCancel: () => {
+                    setFullAccessAcknowledged(false);
+                    fullAccessConfirmation?.resolve(false);
+                }, onConfirm: () => {
+                    setFullAccessAcknowledged(false);
+                    fullAccessConfirmation?.resolve(true);
                 } })] }));
 }
 //# sourceMappingURL=WorktreeSurface.js.map