@cerbur/clutch-dsh-worktree 0.1.6 → 0.1.8

package/lib/client/WorktreeSurface.js

@@ -1,18 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
-import { IconBranchOutline16, IconCloseOutline16, IconPlusOutline16, IconSearchOutline16, } from '@deepseek-ai/dsh-client-ui-primitives';
+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, clearSessionGroupExpansion, includesText, isCompleteWorktreeWorkspaceSnapshot, currentSessionRevealKeys, resolveCurrentSessionLocation, 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, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, loadWorktreeViews, mergeWorktreeView, 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);
@@ -21,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([]);
@@ -33,15 +58,33 @@ 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, expandState, 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('');
@@ -54,9 +97,13 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [modalReadError, setModalReadError] = useState();
     const [modalReadLoading, setModalReadLoading] = useState(false);
     const [worktreeModalMode, setWorktreeModalMode] = useState('create');
-    const [importCandidates, setImportCandidates] = useState({ status: 'idle', candidates: [] });
+    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('');
@@ -64,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);
@@ -83,6 +131,7 @@ 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());
@@ -119,9 +168,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                 throw error;
             setReadState({
                 status: 'error',
-                views: modalReadViewRef.current === undefined
-                    ? []
-                    : [modalReadViewRef.current],
+                views: modalReadViewRef.current === undefined ? [] : [modalReadViewRef.current],
                 error: toWorktreeViewError(error),
             });
         });
@@ -164,6 +211,19 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             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;
@@ -173,6 +233,60 @@ 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]);
@@ -238,11 +352,11 @@ 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 = !modalReadLoading &&
-        modalSetupStatus === undefined &&
-        modalReadiness?.status === 'ready';
+    const modalCanCreate = !modalReadLoading && modalSetupStatus === undefined && modalReadiness?.status === 'ready';
     useEffect(() => {
         if (worktreeModalWorkspaceId === undefined || modalView === undefined)
             return;
@@ -388,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);
@@ -421,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) {
@@ -441,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));
         });
     };
@@ -582,8 +695,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         if (visuallyExpanded)
             clearSessionGroups(['worktree:' + worktreeId]);
     };
-    const toggleSessionGroup = (groupKey) => {
-        const autoExpanded = isCurrentSessionReveal('session-group:' + groupKey);
+    const toggleSessionGroup = (groupKey, autoExpanded) => {
         const transientExpanded = expandedSessionGroups[groupKey] === true;
         if (autoExpanded) {
             suppressCurrentSessionReveal('session-group:' + groupKey);
@@ -609,7 +721,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         setModalReadError(undefined);
         setModalReadLoading(false);
     };
-    const openWorktreeCreator = (workspace) => {
+    const openWorktreeCreator = (workspace, defaults = {}) => {
         const view = viewByWorkspace.get(workspace.workspaceId);
         modalReadLoader.current.invalidate();
         modalReadViewRef.current = undefined;
@@ -622,13 +734,13 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         setModalReadError(undefined);
         setModalReadLoading(false);
         if (view === undefined) {
-            setSelectedBranch('');
-            setNewBranch('');
+            setSelectedBranch(defaults.baseBranch ?? '');
+            setNewBranch(defaults.newBranch ?? '');
             loadModalWorktreeView(workspace.workspaceId);
             return;
         }
-        setSelectedBranch(selectDefaultBaseBranch(view.branches));
-        setNewBranch(createDefaultWorktreeName([
+        setSelectedBranch(defaults.baseBranch ?? selectDefaultBaseBranch(view.branches));
+        setNewBranch(defaults.newBranch ?? createDefaultWorktreeName([
             ...view.branches.map((branch) => branch.name),
             ...view.worktrees.map((worktree) => worktree.branch),
         ]));
@@ -665,6 +777,13 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             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 });
@@ -736,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 {
@@ -743,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);
@@ -758,6 +882,9 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                 ensureSessionWorkspace: (workspaceId, sessionId) => {
                     ensureSessionWorkspace?.(workspaceId, sessionId);
                 },
+                permission,
+                confirmFullAccess,
+                onPermissionResult,
                 openSession,
             });
             setPendingSessionBinding(undefined);
@@ -774,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);
@@ -793,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: () => {
@@ -815,20 +963,30 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                         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 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 mainGroupKey = `main:${workspace.workspaceId}`;
-                                    const sessionIds = visibleMainSessionIds;
+                                    const sessionIds = orderedVisibleMainSessionIds.length === visibleMainSessionIds.length
+                                        ? orderedVisibleMainSessionIds
+                                        : visibleMainSessionIds;
+                                    const mainSessionGroupAutoExpanded = isSessionGroupAutoExpanded(sessionIds, currentSessionId, isCurrentSessionReveal('session-group:' + mainGroupKey));
                                     const mainSessionGroupExpanded = expandedSessionGroups[mainGroupKey] === true ||
-                                        (sessionIds.length > 5 &&
-                                            isCurrentSessionReveal('session-group:' + mainGroupKey));
+                                        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
@@ -872,14 +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: sessionIds, workspaceId: workspace.workspaceId, currentSessionId: currentSessionId, expanded: mainSessionGroupExpanded, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
-                                                            toggleSessionGroup(mainGroupKey);
+                                                            } }), 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 });
@@ -903,27 +1079,37 @@ 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 sessionIds = visibleWorktreeSessionIds;
+                                                        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 ||
-                                                            (sessionIds.length > 5 &&
-                                                                isCurrentSessionReveal('session-group:' + worktreeGroupKey));
+                                                            sessionGroupAutoExpanded;
                                                         const state = record.status === 'removed'
                                                             ? 'warning'
-                                                            : record.health === 'repair'
+                                                            : record.health === 'repair' || record.health === 'recovery-needed'
                                                                 ? 'error'
                                                                 : 'done';
                                                         const stateLabel = record.status === 'removed'
                                                             ? t('worktree.detached')
-                                                            : record.health === 'repair'
-                                                                ? t('worktree.repair')
-                                                                : t('worktree.ready');
+                                                            : record.health === 'recovery-needed'
+                                                                ? t('worktree.recovery')
+                                                                : record.health === 'repair'
+                                                                    ? t('worktree.repair')
+                                                                    : t('worktree.ready');
                                                         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: () => {
+                                                        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'
+                                                                    }, onCreateSession: record.status === 'active' && record.health !== 'repair' && record.health !== 'recovery-needed'
                                                                         ? () => {
                                                                             void createSession({
                                                                                 workspaceId: record.workspaceId,
@@ -931,20 +1117,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' && record.health !== 'repair' && record.health !== 'recovery-needed',
+                                                                        showRemove: record.status === 'active' && record.health !== 'repair' && record.health !== 'recovery-needed',
+                                                                        disabled: actionPending,
+                                                                        onOpenChange: (open) => {
+                                                                            setOpenWorktreeMenuId(open ? record.worktreeId : undefined);
+                                                                        },
+                                                                        onCreateWorktree: record.status === 'active' && record.health !== 'repair' && record.health !== 'recovery-needed'
+                                                                            ? () => {
+                                                                                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
@@ -975,8 +1172,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                             setWorktreeDrag(undefined);
                                                                             worktreeDropCommitted.current = false;
                                                                         },
-                                                                    } }), 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);
+                                                                    } }), 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 });
@@ -1017,17 +1214,41 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                     if (manager === undefined || worktreeRemoval === undefined)
                         return;
                     const target = worktreeRemoval;
+                    const mutationToken = target.mutationToken;
+                    if (mutationToken === undefined) {
+                        setActionError({
+                            code: 'WORKTREE_STATE_CONFLICT',
+                            message: '',
+                            retryable: true,
+                            details: {
+                                workspaceId: target.workspaceId,
+                                worktreeId: target.worktreeId,
+                            },
+                        });
+                        return;
+                    }
                     void runMutation(async () => {
                         await executeWorktreeAction(manager, {
                             type: 'removeWorktree',
                             input: {
                                 workspaceId: target.workspaceId,
                                 worktreeId: target.worktreeId,
+                                mutationToken,
                             },
-                        });
+                        }, 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