@cerbur/clutch-dsh-worktree 0.1.2 → 0.1.4

package/lib/client/WorktreeSurface.js

@@ -1,11 +1,16 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { Button, HoverCard, IconArchiveOutline20, IconBranchOutline16, IconChevronDownOutline14, IconChevronRightOutline14, IconCloseOutline16, IconEditOutline16, IconEllipsisOutline16, IconFolderClose16, IconFolderOpen16, IconPlusOutline16, IconSearchOutline16, IconTrashOutline16, Input, Menu, Modal, StateDot, } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconBranchOutline16, IconCloseOutline16, IconPlusOutline16, IconSearchOutline16, } from '@deepseek-ai/dsh-client-ui-primitives';
 import { openWorktreeSession } from './navigation.js';
 import { useSidebarOverlayGeometry } from './sidebar-overlay-geometry.js';
 import { effectiveViewMode, unboundSessionIds, workspaceSessionIds } from './view-mode.js';
 import { formatWorktreeViewError } from './worktree-error-copy.js';
-import { executeWorktreeAction, createDefaultWorktreeName, filterArchivedSessionIds, loadWorktreeViews, selectDefaultBaseBranch, stableWorkspaceIds, toWorktreeViewError, WorktreeSessionBindingError, } from './worktree-view.js';
+import { filterVisibleSessionIds, sessionMatchesQuery, } from './session-view.js';
+import { retryWorktreeSessionBinding } from './worktree-session.js';
+import { WorktreeCreateDialog, WorktreeRemovalDialog, WorktreeSessionRenameDialog, WorktreeWorkspaceDeleteDialog, WorktreeWorkspaceRenameDialog, } from './worktree-surface-dialogs.js';
+import { bindingIdsFor, includesText, workspaceMatches, } from './worktree-surface-selectors.js';
+import { 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 styles from './worktree.css';
 function toNativeWorktreeViewError(error) {
     const viewError = toWorktreeViewError(error);
@@ -22,230 +27,19 @@ function useStableWorkspaceIds(workspaces) {
         previousRef.current = stable;
     return previousRef.current;
 }
-function sessionLabel(sessionId, sessions) {
-    return sessions.byId[sessionId]?.displayTitle ?? sessionId;
-}
-function rowHalf(event) {
-    const rect = event.currentTarget.getBoundingClientRect();
-    return event.clientY < rect.top + rect.height / 2 ? 'before' : 'after';
-}
-function bindingIdsFor(bindings, worktreeId) {
-    return bindings
-        .filter((binding) => binding.worktreeId === worktreeId)
-        .map((binding) => binding.sessionId);
-}
-function includesText(value, query) {
-    return value.toLocaleLowerCase().includes(query);
-}
-function workspaceMatches(workspace, view, sessions, query) {
-    if (query.length === 0)
-        return true;
-    if (includesText(workspace.title, query))
-        return true;
-    if (workspace.sessionIds.some((sessionId) => includesText(sessionLabel(sessionId, sessions), query))) {
-        return true;
-    }
-    if (view === undefined)
-        return false;
-    if (view.worktrees.some((record) => includesText(record.branch, query) || includesText(record.absolutePath, query))) {
-        return true;
-    }
-    return view.bindings.some((binding) => includesText(sessionLabel(binding.sessionId, sessions), query));
-}
-/** Workspace row using the native DSH menu, fixed action column, and drag contract. */
-function WorktreeWorkspaceRow({ t, workspace, expanded, actionPending, menuOpen, drag, onToggle, onCreateWorktree, onRename, onDelete, onMenuOpenChange, }) {
-    const workspaceMenuItems = [
-        {
-            id: 'rename',
-            label: t('workspace.rename'),
-            icon: _jsx(IconEditOutline16, {}),
-            disabled: actionPending,
-        },
-        {
-            id: 'delete',
-            label: t('workspace.delete'),
-            icon: _jsx(IconTrashOutline16, {}),
-            danger: true,
-            disabled: actionPending,
-        },
-    ];
-    const markerClass = drag.marker === 'before'
-        ? styles.dropBefore
-        : drag.marker === 'after'
-            ? styles.dropAfter
-            : '';
-    return (_jsxs("div", { className: `${styles.workspaceRow} ${markerClass}`, "data-workspace-drag": drag.active ? 'active' : undefined, "data-menu-open": menuOpen || undefined, draggable: true, onClick: () => {
-            onToggle();
-        }, onDragStart: (event) => {
-            event.dataTransfer.effectAllowed = 'move';
-            event.dataTransfer.setData('text/plain', workspace.workspaceId);
-            drag.start();
-        }, onDragEnd: drag.end, onDragOver: (event) => {
-            if (!drag.active)
-                return;
-            event.preventDefault();
-            event.dataTransfer.dropEffect = 'move';
-            drag.hover(rowHalf(event));
-        }, onDrop: (event) => {
-            if (!drag.active)
-                return;
-            event.preventDefault();
-            drag.drop(rowHalf(event));
-        }, children: [_jsx("button", { type: "button", className: `${styles.disclosureButton} ${styles.workspaceDisclosure}`, "aria-label": t(expanded ? 'workspace.collapse' : 'workspace.expand', {
-                    name: workspace.title,
-                }), "aria-expanded": expanded, onClick: (event) => {
-                    event.stopPropagation();
-                    onToggle();
-                }, children: expanded ? (_jsx(IconChevronDownOutline14, { size: 18 })) : (_jsx(IconChevronRightOutline14, { size: 18 })) }), _jsx("span", { className: styles.workspaceIcon, "aria-hidden": "true", children: expanded ? _jsx(IconFolderOpen16, {}) : _jsx(IconFolderClose16, {}) }), _jsx("span", { className: styles.workspaceTitle, children: workspace.title }), _jsxs("span", { className: `${styles.treeActionSlot} ${styles.workspaceActions}`, children: [_jsx("span", { className: styles.menuAction, children: _jsx(Menu, { open: menuOpen, onClose: () => {
-                                onMenuOpenChange(false);
-                            }, items: workspaceMenuItems, onSelect: (id) => {
-                                onMenuOpenChange(false);
-                                if (id === 'rename')
-                                    onRename();
-                                if (id === 'delete')
-                                    onDelete();
-                            }, portal: true, closeOnPointerLeave: true, anchor: (_jsx("button", { type: "button", className: styles.iconButton, "data-workspace-menu": true, "aria-label": t('workspace.options', { name: workspace.title }), onClick: (event) => {
-                                    event.stopPropagation();
-                                    onMenuOpenChange(!menuOpen);
-                                }, children: _jsx(IconEllipsisOutline16, {}) })) }) }), _jsx("button", { type: "button", className: styles.iconButton, "data-add-worktree": true, "aria-label": t('workspace.addWorktree', { name: workspace.title }), onClick: (event) => {
-                            event.stopPropagation();
-                            onCreateWorktree();
-                        }, children: _jsx(IconPlusOutline16, {}) })] })] }));
-}
-/** Shared Main/Worktree group row with parameterized icon, state, and actions. */
-function WorktreeGroupRow({ t, kind, label, expanded, icon, workspaceTitle, state, stateLabel, onToggle, onCreateSession, menu, }) {
-    const main = kind === 'main';
-    const row = (_jsxs("div", { className: styles.worktreeRow, "data-main-group": main ? 'true' : undefined, "data-main-expanded": main ? String(expanded) : undefined, "data-menu-open": menu?.open ? 'true' : undefined, onClick: onToggle, children: [_jsx("button", { type: "button", className: `${styles.disclosureButton} ${styles.worktreeDisclosure}`, "aria-label": t(expanded ? 'worktree.collapse' : 'worktree.expand', { name: label }), "aria-expanded": expanded, onClick: (event) => {
-                    event.stopPropagation();
-                    onToggle();
-                }, children: expanded ? (_jsx(IconChevronDownOutline14, { size: 18 })) : (_jsx(IconChevronRightOutline14, { size: 18 })) }), _jsx("span", { className: styles.worktreeIcon, "aria-hidden": "true", children: icon }), state !== undefined && stateLabel !== undefined && (_jsx("span", { className: styles.worktreeState, role: "img", "aria-label": stateLabel, title: stateLabel, children: _jsx(StateDot, { state: state }) })), _jsx("span", { className: styles.worktreeLabel, children: label }), _jsxs("span", { className: styles.treeActionSlot, children: [menu !== undefined && (_jsx("span", { className: styles.menuAction, children: _jsx(Menu, { open: menu.open, onClose: () => {
-                                menu.onOpenChange(false);
-                            }, items: [
-                                {
-                                    id: 'remove',
-                                    label: t('worktree.remove'),
-                                    icon: _jsx(IconTrashOutline16, {}),
-                                    danger: true,
-                                    disabled: menu.disabled,
-                                },
-                            ], onSelect: (id) => {
-                                menu.onOpenChange(false);
-                                if (id === 'remove')
-                                    menu.onRemove();
-                            }, portal: true, closeOnPointerLeave: true, anchor: _jsx("button", { type: "button", className: styles.iconButton, "data-worktree-menu": true, "aria-label": t('worktree.options', { name: menu.label }), onClick: (event) => {
-                                    event.stopPropagation();
-                                    menu.onOpenChange(!menu.open);
-                                }, children: _jsx(IconEllipsisOutline16, {}) }) }) })), onCreateSession !== undefined && (_jsx("button", { type: "button", className: styles.iconButton, "data-add-main-session": main ? 'true' : undefined, "data-add-session": main ? undefined : 'true', "aria-label": t('worktree.addSession', { name: workspaceTitle }), onClick: (event) => {
-                            event.stopPropagation();
-                            onCreateSession();
-                        }, children: _jsx(IconPlusOutline16, {}) }))] })] }));
-    if (main)
-        return row;
-    return (_jsx(HoverCard, { anchor: row, content: _jsx("div", { className: styles.worktreeHoverTitle, children: label }), openDelayMs: 500, disabled: menu?.open === true }));
-}
-/** Worktree-mode Session row with the same trailing options menu as native DSH rows. */
-function WorktreeSessionRow({ t, sessionId, label, drag, actionPending, onOpen, onRename, onFork, onArchive, }) {
-    const [menuOpen, setMenuOpen] = useState(false);
-    const markerClass = drag.marker === 'before'
-        ? styles.dropBefore
-        : drag.marker === 'after'
-            ? styles.dropAfter
-            : '';
-    const sessionMenuItems = [
-        {
-            id: 'rename',
-            label: t('session.rename'),
-            icon: _jsx(IconEditOutline16, {}),
-            disabled: onRename === undefined || actionPending,
-        },
-        {
-            id: 'fork',
-            label: t('session.fork'),
-            icon: _jsx(IconBranchOutline16, {}),
-            disabled: onFork === undefined || actionPending,
-        },
-        {
-            id: 'archive',
-            label: t('session.archive'),
-            icon: _jsx(IconArchiveOutline20, { size: 16 }),
-            disabled: onArchive === undefined || actionPending,
-        },
-    ];
-    return (_jsxs("div", { className: `${styles.treeSessionRow} ${markerClass}`, "data-session-id": sessionId, "data-session-drag": drag.active ? 'active' : undefined, "data-menu-open": menuOpen || undefined, role: "treeitem", draggable: true, onDragStart: (event) => {
-            event.dataTransfer.effectAllowed = 'move';
-            event.dataTransfer.setData('text/plain', sessionId);
-            drag.start();
-        }, onDragEnd: drag.end, onDragOver: (event) => {
-            if (!drag.active)
-                return;
-            event.preventDefault();
-            event.dataTransfer.dropEffect = 'move';
-            drag.hover(rowHalf(event));
-        }, onDrop: (event) => {
-            if (!drag.active)
-                return;
-            event.preventDefault();
-            drag.drop(rowHalf(event));
-        }, children: [_jsxs("button", { type: "button", className: styles.treeSessionContent, onClick: onOpen, children: [_jsx("span", { className: styles.treeGuide, "aria-hidden": "true", children: "\u2514" }), _jsx("span", { className: styles.sessionLabel, children: label })] }), _jsx("span", { className: styles.rowActions, children: _jsx(Menu, { open: menuOpen, onClose: () => {
-                        setMenuOpen(false);
-                    }, items: sessionMenuItems, onSelect: (id) => {
-                        setMenuOpen(false);
-                        if (id === 'rename')
-                            onRename?.(sessionId, label);
-                        if (id === 'fork')
-                            onFork?.(sessionId);
-                        if (id === 'archive')
-                            onArchive?.(sessionId);
-                    }, portal: true, closeOnPointerLeave: true, anchor: (_jsx("button", { type: "button", className: styles.iconButton, "data-session-menu": true, "aria-label": t('session.options', { name: label }), onClick: (event) => {
-                            event.stopPropagation();
-                            setMenuOpen((current) => !current);
-                        }, children: _jsx(IconEllipsisOutline16, {}) })) }) })] }));
-}
-function WorktreeSessionGroup({ t, groupKey, sessionIds, workspaceId, expanded, actionPending, sessions, dragState, onToggleExpanded, onStartDrag, onHoverDrag, onClearDrag, onFinishDrag, onCommitDrag, onOpen, onRename, onFork, onArchive, }) {
-    const visibleSessionIds = expanded ? sessionIds : sessionIds.slice(0, 5);
-    const sameGroupDrag = dragState?.groupKey === groupKey;
-    return (_jsxs(_Fragment, { children: [visibleSessionIds.map((sessionId) => (_jsx(WorktreeSessionRow, { t: t, sessionId: sessionId, label: sessionLabel(sessionId, sessions), drag: {
-                    active: sameGroupDrag,
-                    marker: sameGroupDrag && dragState.over?.sessionId === sessionId
-                        ? dragState.over.half
-                        : null,
-                    start: () => {
-                        onStartDrag(groupKey, sessionId);
-                    },
-                    hover: (half) => {
-                        onHoverDrag(sessionId, half);
-                    },
-                    drop: (half) => {
-                        if (dragState === undefined)
-                            return;
-                        onCommitDrag(dragState, { sessionId, half }, sessionIds, workspaceId);
-                    },
-                    end: () => {
-                        if (dragState?.over !== null && dragState?.over !== undefined) {
-                            onCommitDrag(dragState, dragState.over, sessionIds, workspaceId);
-                        }
-                        else {
-                            onClearDrag();
-                        }
-                        onFinishDrag();
-                    },
-                }, actionPending: actionPending, onOpen: () => {
-                    onOpen(sessionId);
-                }, onRename: onRename, onFork: onFork, onArchive: onArchive }, `${groupKey}:${sessionId}`))), sessionIds.length > 5 && (_jsx("button", { type: "button", className: styles.sessionOverflowButton, "aria-expanded": expanded, onClick: onToggleExpanded, children: expanded
-                    ? t('session.collapse')
-                    : t('session.expandMore', { count: sessionIds.length - 5 }) }))] }));
-}
 /**
  * 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, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, renameSession, forkSession, archiveSession, ensureSessionWorkspace, syncSessionWorkspaces, openSession, }) {
+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, }) {
     const preferredMode = useStore((state) => state.viewMode);
     const mode = effectiveViewMode(preferredMode, available && manager !== undefined);
     const sessions = useSessions((state) => state);
     const workspaces = useWorkspaces((state) => state);
     const workspaceIds = useStableWorkspaceIds(workspaces.items);
     const [readState, setReadState] = useState(EMPTY_READ_STATE);
+    const readStateRef = useRef(readState);
+    readStateRef.current = readState;
     const [searchQuery, setSearchQuery] = useState('');
     const [expandedWorkspaces, setExpandedWorkspaces] = useState({});
     const [expandedMains, setExpandedMains] = useState({});
@@ -275,33 +69,46 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [sessionDrag, setSessionDrag] = useState();
     const [expandedSessionGroups, setExpandedSessionGroups] = useState({});
     const sessionDropCommitted = useRef(false);
+    const [worktreeDrag, setWorktreeDrag] = useState();
+    const worktreeDropCommitted = useRef(false);
+    const refreshGuard = useRef(createWorktreeRefreshGuard());
     const { ref, width, bounds } = useSidebarOverlayGeometry(mode === 'worktree');
     const collapsed = width <= 64;
     const query = searchQuery.trim().toLocaleLowerCase();
     const archivedSessionIds = workspaces.archivedSessionIds ?? [];
-    const refresh = useCallback(async () => {
+    const pendingSessionArchived = pendingSessionBinding !== undefined &&
+        archivedSessionIds.includes(pendingSessionBinding.sessionId);
+    const refresh = useCallback(async (options = {}) => {
         if (manager === undefined) {
+            refreshGuard.current.invalidate();
             setReadState(EMPTY_READ_STATE);
             return;
         }
-        setReadState({ status: 'loading', views: [] });
-        try {
-            const views = await loadWorktreeViews(manager, workspaceIds);
-            setReadState({ status: 'ready', views });
+        const preserveCurrent = options.preserveCurrent === true;
+        if (!preserveCurrent) {
+            setReadState({ status: 'loading', views: [] });
         }
-        catch (error) {
+        await refreshGuard.current.run(() => loadWorktreeViews(manager, workspaceIds, {
+            invalidateContext: options.invalidateContext !== false,
+            invalidateWorktreeContext,
+        }), (views) => {
+            setReadState({ status: 'ready', views });
+        }, (error) => {
+            if (preserveCurrent)
+                throw error;
             setReadState({
                 status: 'error',
                 views: [],
                 error: toWorktreeViewError(error),
             });
-        }
-    }, [manager, workspaceIds]);
+        });
+    }, [invalidateWorktreeContext, manager, workspaceIds]);
     useEffect(() => {
         if (mode === 'worktree') {
-            void refresh();
+            void refresh({ preserveCurrent: readStateRef.current.status === 'ready' });
         }
         else {
+            refreshGuard.current.invalidate();
             setReadState(EMPTY_READ_STATE);
         }
     }, [mode, refresh]);
@@ -318,12 +125,28 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const modalView = worktreeModalWorkspaceId === undefined
         ? undefined
         : viewByWorkspace.get(worktreeModalWorkspaceId);
+    const modalReadiness = modalView?.readiness;
+    const modalSetupStatus = modalView === undefined
+        ? undefined
+        : modalReadiness?.status === 'ready'
+            ? modalView.branches.length === 0 ? 'noLocalBranch' : undefined
+            : modalReadiness?.status;
+    const modalCanCreate = modalSetupStatus === undefined && modalReadiness?.status === 'ready';
+    useEffect(() => {
+        if (worktreeModalWorkspaceId === undefined || modalView === undefined)
+            return;
+        if (modalView.readiness.status !== 'ready') {
+            setSelectedBranch('');
+            return;
+        }
+        setSelectedBranch((current) => reconcileBaseBranchSelection(current, modalView.branches));
+    }, [modalView, worktreeModalWorkspaceId]);
     const runMutation = async (operation) => {
         setActionPending(true);
         setActionError(undefined);
         try {
             await operation();
-            await refresh();
+            await refresh({ preserveCurrent: true });
         }
         catch (error) {
             setActionError(toWorktreeViewError(error));
@@ -483,6 +306,31 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             setActionError(toWorktreeViewError(error));
         });
     };
+    const commitWorktreeDrag = (activeDrag, over, worktreeIds, workspaceId) => {
+        if (worktreeDropCommitted.current)
+            return;
+        worktreeDropCommitted.current = true;
+        setWorktreeDrag(undefined);
+        if (activeDrag.workspaceId !== workspaceId)
+            return;
+        const move = resolveWorktreeMove(worktreeIds, activeDrag.worktreeId, over.worktreeId, over.half);
+        if (move === undefined)
+            return;
+        if (insertWorktreeBefore === undefined) {
+            setActionError({
+                code: 'WORKTREE_ORDER_UNAVAILABLE',
+                message: '',
+                retryable: true,
+            });
+            return;
+        }
+        setActionError(undefined);
+        void insertWorktreeBefore(workspaceId, activeDrag.worktreeId, move.beforeWorktreeId)
+            .then(() => refresh({ preserveCurrent: true, invalidateContext: false }))
+            .catch((error) => {
+            setActionError(toRetryableWorktreeOrderError(error));
+        });
+    };
     const openSessionRename = (sessionId, currentTitle) => {
         setSessionRenameTarget({ sessionId, currentTitle });
         setSessionRenameDraft(currentTitle);
@@ -559,6 +407,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         const worktreeName = newBranch.trim();
         if (manager === undefined ||
             modalWorkspace === undefined ||
+            !modalCanCreate ||
             selectedBranch.length === 0 ||
             worktreeName.length === 0) {
             return;
@@ -585,7 +434,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             }
             setWorktreeModalWorkspaceId(undefined);
             if (createSessionCallback === undefined) {
-                await refresh();
+                await refresh({ preserveCurrent: true });
                 setActionError({
                     code: 'WORKTREE_CREATED_SESSION_UNAVAILABLE',
                     message: '',
@@ -600,14 +449,15 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             };
             try {
                 await createSessionCallback(sessionInput);
+                await invalidateWorktreeContext?.(createdWorktree.workspaceId);
             }
             catch (error) {
-                if (error instanceof WorktreeSessionBindingError) {
+                if (error instanceof WorktreeSessionBindingError && error.retryable) {
                     setPendingSessionBinding({ ...sessionInput, sessionId: error.sessionId });
                 }
                 throw error;
             }
-            await refresh();
+            await refresh({ preserveCurrent: true });
         }
         catch (error) {
             setActionError(toWorktreeViewError(error));
@@ -630,10 +480,11 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         setPendingSessionBinding(undefined);
         try {
             await createSessionCallback(input);
-            await refresh();
+            await invalidateWorktreeContext?.(input.workspaceId);
+            await refresh({ preserveCurrent: true });
         }
         catch (error) {
-            if (error instanceof WorktreeSessionBindingError) {
+            if (error instanceof WorktreeSessionBindingError && error.retryable) {
                 setPendingSessionBinding({ ...input, sessionId: error.sessionId });
             }
             setActionError(toWorktreeViewError(error));
@@ -643,23 +494,31 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         }
     };
     const retrySessionBinding = async () => {
-        if (manager === undefined || pendingSessionBinding === undefined)
+        if (manager === undefined ||
+            pendingSessionBinding === undefined ||
+            pendingSessionArchived)
             return;
+        const pending = pendingSessionBinding;
         setActionPending(true);
         setActionError(undefined);
         try {
-            await manager.bindSession({
-                workspaceId: pendingSessionBinding.workspaceId,
-                worktreeId: pendingSessionBinding.worktreeId,
-                sessionId: pendingSessionBinding.sessionId,
+            await retryWorktreeSessionBinding({
+                manager,
+                pending,
+                archived: false,
+                ensureSessionWorkspace: (workspaceId, sessionId) => {
+                    ensureSessionWorkspace?.(workspaceId, sessionId);
+                },
+                openSession,
             });
-            const sessionId = pendingSessionBinding.sessionId;
             setPendingSessionBinding(undefined);
-            ensureSessionWorkspace?.(pendingSessionBinding.workspaceId, sessionId);
-            await refresh();
-            openSession(sessionId);
+            await refresh({ preserveCurrent: true });
+            await invalidateWorktreeContext?.(pending.workspaceId);
         }
         catch (error) {
+            if (error instanceof WorktreeSessionBindingError && !error.retryable) {
+                setPendingSessionBinding(undefined);
+            }
             setActionError(toWorktreeViewError(error));
         }
         finally {
@@ -685,7 +544,7 @@ 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, onClick: () => {
+                                }, 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: () => {
                                                     void retrySessionBinding();
                                                 }, children: t('action.retryBinding') }), _jsx("button", { type: "button", className: styles.actionButton, disabled: actionPending, onClick: () => {
                                                     const sessionId = pendingSessionBinding.sessionId;
@@ -699,19 +558,21 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                             void refresh();
                                         }, children: t('action.retry') })] })) : readState.status === 'ready' ? (_jsx("div", { className: styles.workspaceList, children: visibleWorkspaces.length === 0 ? (_jsx("p", { className: styles.empty, children: t('workspace.noMatches') })) : (visibleWorkspaces.map((workspace) => {
                                     const view = viewByWorkspace.get(workspace.workspaceId);
+                                    const currentBranch = view?.branches.find((branch) => branch.isCurrent)?.name;
+                                    const mainLabel = currentBranch === undefined
+                                        ? t('worktree.main')
+                                        : t('worktree.mainWithBranch', { branch: currentBranch });
                                     const expanded = expandedWorkspaces[workspace.workspaceId] !== false;
                                     const workspaceMatchesQuery = includesText(workspace.title, query);
                                     const allWorkspaceSessionIds = filterArchivedSessionIds(workspaceSessionIds(workspaces, workspace.workspaceId, sessions.ids), archivedSessionIds);
                                     const bindings = view?.bindings ?? [];
                                     const boundSessionIds = new Set(bindings.map((binding) => binding.sessionId));
-                                    const mainSessionIds = unboundSessionIds(allWorkspaceSessionIds, [
-                                        ...boundSessionIds,
-                                    ]);
-                                    const visibleMainSessionIds = mainSessionIds.filter((sessionId) => workspaceMatchesQuery ||
-                                        includesText(sessionLabel(sessionId, sessions), query));
+                                    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 worktrees = view?.worktrees ?? [];
+                                    const sameWorkspaceWorktreeDrag = worktreeDrag?.workspaceId === workspace.workspaceId;
                                     return (_jsxs("section", { className: styles.workspaceGroup, "data-workspace-id": workspace.workspaceId, children: [_jsx(WorktreeWorkspaceRow, { t: t, workspace: workspace, expanded: expanded, actionPending: actionPending, menuOpen: openWorkspaceMenuId === workspace.workspaceId, drag: {
                                                     active: workspaceDrag !== undefined,
                                                     marker: workspaceDrag?.over?.workspaceId === workspace.workspaceId
@@ -756,7 +617,7 @@ 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: t('worktree.main'), 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, icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, onToggle: () => {
                                                             toggleMain(workspace.workspaceId);
                                                         }, onCreateSession: createMainSession === undefined
                                                             ? undefined
@@ -781,17 +642,16 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                         }, onCommitDrag: commitSessionDrag, onOpen: (sessionId) => {
                                                             openWorktreeSession({ open: openSession }, sessionId);
                                                         }, onRename: renameSession === undefined ? undefined : openSessionRename, onFork: forkSession, onArchive: archiveSession === undefined ? undefined : archiveWorktreeSession })), worktrees.length === 0 && (_jsx("p", { className: styles.emptyNested, children: t('worktree.noWorktrees') })), worktrees.map((record) => {
-                                                        const worktreeSessionIds = filterArchivedSessionIds(bindingIdsFor(bindings, record.worktreeId).filter((sessionId) => sessions.ids.includes(sessionId)), archivedSessionIds);
+                                                        const worktreeSessionIds = filterVisibleSessionIds(filterArchivedSessionIds(bindingIdsFor(bindings, record.worktreeId).filter((sessionId) => sessions.ids.includes(sessionId)), archivedSessionIds), sessions);
                                                         const worktreeMatchesQuery = workspaceMatchesQuery ||
                                                             includesText(record.branch, query) ||
                                                             includesText(record.absolutePath, query);
                                                         if (query.length > 0 &&
                                                             !worktreeMatchesQuery &&
-                                                            !worktreeSessionIds.some((sessionId) => includesText(sessionLabel(sessionId, sessions), query))) {
+                                                            !worktreeSessionIds.some((sessionId) => sessionMatchesQuery(sessionId, sessions, query))) {
                                                             return null;
                                                         }
-                                                        const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery ||
-                                                            includesText(sessionLabel(sessionId, sessions), query));
+                                                        const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
                                                         const worktreeGroupKey = `worktree:${record.worktreeId}`;
                                                         const state = record.status === 'removed'
                                                             ? 'warning'
@@ -804,9 +664,9 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                 ? 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, 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, icon: _jsx(IconBranchOutline16, {}), workspaceTitle: workspace.title, state: state, stateLabel: stateLabel, onToggle: () => {
                                                                         toggleWorktree(record.worktreeId);
-                                                                    }, onCreateSession: record.status === 'active'
+                                                                    }, onCreateSession: record.status === 'active' && record.health !== 'repair'
                                                                         ? () => {
                                                                             void createSession({
                                                                                 workspaceId: record.workspaceId,
@@ -827,7 +687,38 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                                                 setActionError(undefined);
                                                                             },
                                                                         }
-                                                                        : undefined }), worktreeExpanded && (_jsx(WorktreeSessionGroup, { t: t, groupKey: worktreeGroupKey, sessionIds: visibleWorktreeSessionIds, workspaceId: workspace.workspaceId, expanded: expandedSessionGroups[worktreeGroupKey] === true, actionPending: actionPending, sessions: sessions, dragState: sessionDrag, onToggleExpanded: () => {
+                                                                        : undefined, drag: {
+                                                                        active: sameWorkspaceWorktreeDrag,
+                                                                        marker: worktreeDrag?.over?.worktreeId === record.worktreeId
+                                                                            ? worktreeDrag.over.half
+                                                                            : null,
+                                                                        start: () => {
+                                                                            worktreeDropCommitted.current = false;
+                                                                            setWorktreeDrag({
+                                                                                workspaceId: workspace.workspaceId,
+                                                                                worktreeId: record.worktreeId,
+                                                                                over: null,
+                                                                            });
+                                                                        },
+                                                                        hover: (half) => {
+                                                                            setWorktreeDrag((current) => current === undefined ||
+                                                                                current.workspaceId !== workspace.workspaceId
+                                                                                ? current
+                                                                                : {
+                                                                                    ...current,
+                                                                                    over: { worktreeId: record.worktreeId, half },
+                                                                                });
+                                                                        },
+                                                                        drop: (half) => {
+                                                                            if (worktreeDrag === undefined)
+                                                                                return;
+                                                                            commitWorktreeDrag(worktreeDrag, { worktreeId: record.worktreeId, half }, worktrees.map((candidate) => candidate.worktreeId), workspace.workspaceId);
+                                                                        },
+                                                                        end: () => {
+                                                                            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,
@@ -851,66 +742,31 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                     })] }))] }, workspace.workspaceId));
                                 })) })) : null] })] }), _jsx("div", { className: styles.railContent, children: _jsx("button", { type: "button", className: styles.railButton, "aria-label": t('mode.exit'), onClick: () => {
                         actions.setViewMode('workspace-session');
-                    }, children: "WT" }) }), _jsxs(Modal, { open: sessionRenameTarget !== undefined, onClose: closeSessionRename, closeLabel: t('dialog.close'), title: t('session.rename'), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: sessionRenamePending, onClick: closeSessionRename, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: sessionRenamePending || sessionRenameDraft.trim().length === 0, onClick: () => {
-                                void confirmSessionRename();
-                            }, children: t('dialog.rename') })] })), children: [_jsx(Input, { className: styles.renameInput, value: sessionRenameDraft, "aria-label": t('session.name'), autoFocus: true, disabled: sessionRenamePending, onFocus: (event) => {
-                            event.currentTarget.select();
-                        }, onChange: (event) => {
-                            setSessionRenameDraft(event.currentTarget.value);
-                            setSessionRenameError(undefined);
-                        }, onKeyDown: (event) => {
-                            if (event.key === 'Enter' && !event.nativeEvent.isComposing) {
-                                event.preventDefault();
-                                void confirmSessionRename();
-                            }
-                        } }), sessionRenameError !== undefined && (_jsx("p", { className: styles.renameError, role: "alert", children: formatWorktreeViewError(sessionRenameError, t) }))] }), workspaceRenameTarget !== undefined && (_jsxs(Modal, { open: workspaceRenameTarget !== undefined, onClose: closeWorkspaceRename, closeLabel: t('dialog.closeWorkspaceRename'), title: t('workspace.renameTitle'), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: workspaceRenamePending, onClick: closeWorkspaceRename, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: workspaceRenameBlocked, onClick: () => {
-                                void confirmWorkspaceRename();
-                            }, children: t('dialog.rename') })] })), children: [_jsx(Input, { className: styles.renameInput, value: workspaceRenameDraft, "aria-label": t('workspace.name'), autoFocus: true, disabled: workspaceRenamePending, onFocus: (event) => {
-                            event.currentTarget.select();
-                        }, onChange: (event) => {
-                            setWorkspaceRenameDraft(event.currentTarget.value);
-                            setWorkspaceRenameError(undefined);
-                        }, onKeyDown: (event) => {
-                            if (event.key === 'Enter' && !event.nativeEvent.isComposing) {
-                                event.preventDefault();
-                                void confirmWorkspaceRename();
-                            }
-                        } }), workspaceRenameDuplicate && (_jsx("p", { className: styles.renameError, role: "alert", children: t('workspace.duplicate') })), workspaceRenameError !== undefined && (_jsx("p", { className: styles.renameError, role: "alert", children: formatWorktreeViewError(workspaceRenameError, t) }))] })), workspaceDeleteTarget !== undefined && (_jsx(Modal, { open: workspaceDeleteTarget !== undefined, onClose: closeWorkspaceDelete, closeLabel: t('dialog.closeWorkspaceDelete'), title: t('workspace.deleteTitle'), description: t('workspace.deleteDescription', { name: workspaceDeleteTarget.title }), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: workspaceDeletePending, onClick: closeWorkspaceDelete, children: t('dialog.cancel') }), _jsx(Button, { variant: "outline", disabled: workspaceDeletePending, onClick: () => {
-                                void confirmWorkspaceDelete();
-                            }, children: t('dialog.delete') })] })), children: workspaceDeleteError !== undefined && (_jsx("p", { className: styles.renameError, role: "alert", children: formatWorktreeViewError(workspaceDeleteError, t) })) })), worktreeModalWorkspaceId !== undefined && modalWorkspace !== undefined && (_jsxs(Modal, { open: worktreeModalWorkspaceId !== undefined, onClose: () => {
-                    if (actionPending)
-                        return;
+                    }, children: "WT" }) }), _jsx(WorktreeSessionRenameDialog, { t: t, target: sessionRenameTarget, draft: sessionRenameDraft, pending: sessionRenamePending, error: sessionRenameError, onClose: closeSessionRename, onDraftChange: (draft) => {
+                    setSessionRenameDraft(draft);
+                    setSessionRenameError(undefined);
+                }, onSubmit: confirmSessionRename }), _jsx(WorktreeWorkspaceRenameDialog, { t: t, target: workspaceRenameTarget, draft: workspaceRenameDraft, pending: workspaceRenamePending, duplicate: workspaceRenameDuplicate, error: workspaceRenameError, onClose: closeWorkspaceRename, onDraftChange: (draft) => {
+                    setWorkspaceRenameDraft(draft);
+                    setWorkspaceRenameError(undefined);
+                }, onSubmit: confirmWorkspaceRename }), _jsx(WorktreeWorkspaceDeleteDialog, { t: t, target: workspaceDeleteTarget, pending: workspaceDeletePending, error: workspaceDeleteError, onClose: closeWorkspaceDelete, onSubmit: confirmWorkspaceDelete }), _jsx(WorktreeCreateDialog, { t: t, workspace: modalWorkspace, view: modalView, setupStatus: modalSetupStatus, canCreate: modalCanCreate, selectedBranch: selectedBranch, newBranch: newBranch, actionPending: actionPending, onClose: () => {
                     setWorktreeModalWorkspaceId(undefined);
-                }, closeLabel: t('dialog.closeWorktreeCreate'), title: t('worktree.createTitle'), description: t('worktree.createDescription', { name: modalWorkspace.title }), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: actionPending, onClick: () => {
-                                setWorktreeModalWorkspaceId(undefined);
-                            }, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: actionPending ||
-                                selectedBranch.length === 0 ||
-                                newBranch.trim().length === 0, onClick: () => {
-                                void submitWorktree();
-                            }, children: t('worktree.create') })] })), children: [_jsxs("label", { className: styles.modalField, children: [t('worktree.baseBranch'), _jsxs("select", { className: styles.actionSelect, "aria-label": t('worktree.baseBranch'), value: selectedBranch, disabled: actionPending, onChange: (event) => {
-                                    setSelectedBranch(event.currentTarget.value);
-                                }, children: [_jsx("option", { value: "", children: t('worktree.noLocalBranch') }), (modalView?.branches ?? []).map((branch) => (_jsxs("option", { value: branch.name, children: [branch.name, branch.isCurrent ? t('branch.current') : '', branch.checkedOut ? t('branch.checkedOut') : ''] }, branch.name)))] })] }), _jsxs("label", { className: styles.modalField, children: [t('worktree.name'), _jsx(Input, { className: styles.renameInput, "aria-label": t('worktree.name'), value: newBranch, placeholder: "dsh/12345678", disabled: actionPending, onChange: (event) => {
-                                    setNewBranch(event.currentTarget.value);
-                                } })] }), modalView?.branches.length === 0 && (_jsx("p", { className: styles.empty, children: t('worktree.noBranches') }))] })), worktreeRemoval !== undefined && (_jsx(Modal, { open: worktreeRemoval !== undefined, onClose: () => {
-                    if (actionPending)
-                        return;
+                }, onSelectedBranchChange: setSelectedBranch, onNewBranchChange: setNewBranch, onSubmit: submitWorktree }), _jsx(WorktreeRemovalDialog, { t: t, worktree: worktreeRemoval, actionPending: actionPending, onClose: () => {
                     setWorktreeRemoval(undefined);
-                }, closeLabel: t('dialog.closeWorktreeRemove'), title: t('worktree.remove'), description: t('worktree.removeDescription', { name: worktreeRemoval.branch }), footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", disabled: actionPending, onClick: () => {
-                                setWorktreeRemoval(undefined);
-                            }, children: t('dialog.cancel') }), _jsx(Button, { variant: "primary", disabled: actionPending, onClick: () => {
-                                if (manager === undefined)
-                                    return;
-                                const target = worktreeRemoval;
-                                void runMutation(async () => {
-                                    await executeWorktreeAction(manager, {
-                                        type: 'removeWorktree',
-                                        input: {
-                                            workspaceId: target.workspaceId,
-                                            worktreeId: target.worktreeId,
-                                        },
-                                    });
-                                    setWorktreeRemoval(undefined);
-                                });
-                            }, children: t('worktree.remove') })] })) }))] }));
+                }, onSubmit: () => {
+                    if (manager === undefined || worktreeRemoval === undefined)
+                        return;
+                    const target = worktreeRemoval;
+                    void runMutation(async () => {
+                        await executeWorktreeAction(manager, {
+                            type: 'removeWorktree',
+                            input: {
+                                workspaceId: target.workspaceId,
+                                worktreeId: target.worktreeId,
+                            },
+                        });
+                        await invalidateWorktreeContext?.(target.workspaceId);
+                        setWorktreeRemoval(undefined);
+                    });
+                } })] }));
 }
 //# sourceMappingURL=WorktreeSurface.js.map