@cerbur/clutch-dsh-worktree 0.1.9 → 0.1.10

package/lib/client/WorktreeSurface.js

@@ -1,1430 +1,55 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
-import { IconBranchOutline16, IconCloseOutline16, IconProjectAddOutline16, IconSearchOutline16, RiskConfirmation, } from '@deepseek-ai/dsh-client-ui-primitives';
-import { openWorktreeSession } from './navigation.js';
-import { useSidebarOverlayGeometry } from './sidebar-overlay-geometry.js';
-import { isMainExpanded, isWorkspaceExpanded, isWorktreeExpanded, } from './worktree-expand-state.js';
-import { effectiveViewMode, unboundSessionIds, workspaceSessionIds } from './view-mode.js';
-import { 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, 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, createNumberedWorktreeName, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, mergeWorktreeView, mergeWorktreeViews, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, WorktreeSessionPermissionError, } from './worktree-view.js';
+import { AccessConfirmation } from './surface/components/AccessConfirmation.js';
+import { LifecycleDialogs } from './surface/components/LifecycleDialogs.js';
+import { NativeDialogs } from './surface/components/NativeDialogs.js';
+import { RegistrationDialog } from './surface/components/RegistrationDialog.js';
+import { SurfaceContent } from './surface/components/SurfaceContent.js';
+import { SurfaceHeader } from './surface/components/SurfaceHeader.js';
+import { useDragActions } from './surface/actions/useDragActions.js';
+import { useLifecycleActions } from './surface/actions/useLifecycleActions.js';
+import { useLifecycleState } from './surface/state/useLifecycleState.js';
+import { useNativeActions } from './surface/actions/useNativeActions.js';
+import { useRegistrationState } from './surface/state/useRegistrationState.js';
+import { useSessionActions } from './surface/actions/useSessionActions.js';
+import { useSessionExpansion } from './surface/state/useSessionExpansion.js';
+import { useSessionOrdering } from './surface/state/useSessionOrdering.js';
+import { useSurfaceMenus } from './surface/state/useSurfaceMenus.js';
+import { useSurfaceMutation } from './surface/actions/useSurfaceMutation.js';
+import { useSurfaceRefresh } from './surface/state/useSurfaceRefresh.js';
+import { useSurfaceSources } from './surface/state/useSurfaceSources.js';
+import { useWorktreeRegistration } from './surface/actions/useWorktreeRegistration.js';
 import styles from './worktree.css';
-function toNativeWorktreeViewError(error) {
-    const viewError = toWorktreeViewError(error);
-    if (typeof error === 'object' && error !== null)
-        return viewError;
-    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: [],
-    affectedWorkspaceIds: [],
-};
-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([]);
-    const stable = stableWorkspaceIds(previousRef.current, next);
-    if (stable !== previousRef.current)
-        previousRef.current = stable;
-    return previousRef.current;
-}
-/**
- * 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, sessionOrder, manager, viewReader, 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 workspaceIdsRef = useRef(workspaceIds);
-    workspaceIdsRef.current = workspaceIds;
-    const [readState, setReadState] = useState(EMPTY_READ_STATE);
-    const expandSnapshot = useSyncExternalStore(expandState.subscribe, expandState.getSnapshot, expandState.getSnapshot);
-    const permissionNoticeSnapshot = useSyncExternalStore(permissionNotice?.subscribe ?? EMPTY_PERMISSION_NOTICE_SUBSCRIBE, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT);
-    const fullAccessConfirmationSnapshot = useSyncExternalStore(fullAccessConfirmation?.subscribe ?? EMPTY_FULL_ACCESS_CONFIRMATION_SUBSCRIBE, fullAccessConfirmation?.getSnapshot ?? EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT, fullAccessConfirmation?.getSnapshot ?? EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT);
-    const fullAccessConfirmationKey = fullAccessConfirmationSnapshot === undefined
-        ? ''
-        : [
-            fullAccessConfirmationSnapshot.workspaceId,
-            fullAccessConfirmationSnapshot.worktreeId,
-            fullAccessConfirmationSnapshot.sessionId,
-            fullAccessConfirmationSnapshot.cwd,
-        ].join('\u0000');
-    const [fullAccessAcknowledged, setFullAccessAcknowledged] = useState(false);
-    useEffect(() => {
-        setFullAccessAcknowledged(false);
-    }, [fullAccessConfirmationKey]);
-    const sessionOrderSnapshot = useSyncExternalStore(sessionOrder.subscribe, sessionOrder.getSnapshot, sessionOrder.getSnapshot);
-    const sessionPresentations = useMemo(() => deriveSessionPresentationIndex(sessions), [sessions.byId]);
-    const readStateRef = useRef(readState);
-    readStateRef.current = readState;
-    const [searchQuery, setSearchQuery] = useState('');
-    const [currentSessionReveal, setCurrentSessionReveal] = useState();
-    const searchQueryRef = useRef(searchQuery);
-    searchQueryRef.current = searchQuery;
-    const locateGenerationRef = useRef(0);
-    const positionedLocateGenerationRef = useRef();
-    const [worktreeModalWorkspaceId, setWorktreeModalWorkspaceId] = useState();
-    const [modalReadError, setModalReadError] = useState();
-    const [modalReadLoading, setModalReadLoading] = useState(false);
-    const [worktreeModalMode, setWorktreeModalMode] = useState('create');
-    const [importCandidates, setImportCandidates] = useState({
-        status: 'idle',
-        candidates: [],
+/** Composes independent surface state/action domains into the sidebar overlay. */
+export function WorktreeSurface(props) {
+    const source = useSurfaceSources({ props });
+    const registrationState = useRegistrationState({ props });
+    const read = useSurfaceRefresh({ source, props, registrationState });
+    const mutation = useSurfaceMutation({ read });
+    const lifecycleState = useLifecycleState({ props, source, mutation });
+    const menus = useSurfaceMenus();
+    const ordering = useSessionOrdering({ read, source, props });
+    const expansion = useSessionExpansion({ read, source, props });
+    const native = useNativeActions({ source, props, mutation });
+    const drag = useDragActions({ source, props, mutation, read });
+    const session = useSessionActions({ source, props, mutation, read });
+    const registration = useWorktreeRegistration({
+        source,
+        registrationState,
+        read,
+        props,
+        mutation,
+        session,
     });
-    const [selectedImportPath, setSelectedImportPath] = useState();
-    const [openWorkspaceMenuId, setOpenWorkspaceMenuId] = useState();
-    const [openMainMenuId, setOpenMainMenuId] = useState();
-    const [openWorktreeMenuId, setOpenWorktreeMenuId] = useState();
-    const [worktreeRemoval, setWorktreeRemoval] = useState();
-    const [selectedBranch, setSelectedBranch] = useState('');
-    const [newBranch, setNewBranch] = useState('');
-    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);
-    const [sessionRenameError, setSessionRenameError] = useState();
-    const [workspaceDrag, setWorkspaceDrag] = useState();
-    const [workspaceRenameTarget, setWorkspaceRenameTarget] = useState();
-    const [workspaceRenameDraft, setWorkspaceRenameDraft] = useState('');
-    const [workspaceRenamePending, setWorkspaceRenamePending] = useState(false);
-    const [workspaceRenameError, setWorkspaceRenameError] = useState();
-    const [workspaceDeleteTarget, setWorkspaceDeleteTarget] = useState();
-    const [workspaceDeletePending, setWorkspaceDeletePending] = useState(false);
-    const [workspaceDeleteError, setWorkspaceDeleteError] = useState();
-    const workspaceDropCommitted = useRef(false);
-    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 targetRefreshGuards = useRef(new Map());
-    const forkRecoveryRevisionRef = useRef(forkRecoverySnapshot.revision);
-    const modalReadLoader = useRef(createWorktreeModalViewLoader(viewReader));
-    const modalReadViewRef = useRef();
-    const importCandidatesGuard = useRef(createWorktreeRefreshGuard());
-    const modalWorkspaceIdRef = useRef(worktreeModalWorkspaceId);
-    modalWorkspaceIdRef.current = worktreeModalWorkspaceId;
-    const { ref, width, bounds } = useSidebarOverlayGeometry(mode === 'worktree');
-    const collapsed = width <= 64;
-    const query = searchQuery.trim().toLocaleLowerCase();
-    const archivedSessionIds = workspaces.archivedSessionIds ?? [];
-    const pendingSessionArchived = pendingSessionBinding !== undefined &&
-        archivedSessionIds.includes(pendingSessionBinding.sessionId);
-    const guardFor = (workspaceId) => {
-        const current = targetRefreshGuards.current.get(workspaceId);
-        if (current !== undefined)
-            return current;
-        const created = createWorktreeRefreshGuard();
-        targetRefreshGuards.current.set(workspaceId, created);
-        return created;
-    };
-    const refresh = useCallback(async (options = {}) => {
-        if (manager === undefined) {
-            refreshGuard.current.invalidate();
-            for (const guard of targetRefreshGuards.current.values())
-                guard.invalidate();
-            setReadState(EMPTY_READ_STATE);
-            return;
-        }
-        const scope = options.scope ?? { kind: 'global' };
-        const preserveCurrent = options.preserveCurrent === true;
-        const currentWorkspaceIds = workspaceIdsRef.current;
-        if (scope.kind === 'global') {
-            if (!preserveCurrent) {
-                setReadState({ status: 'loading', views: [] });
-            }
-            const selectedWorkspaceIds = [...currentWorkspaceIds];
-            for (const workspaceId of selectedWorkspaceIds) {
-                viewReader.invalidate(workspaceId);
-            }
-            const contextRefresh = options.invalidateContext === false
-                ? undefined
-                : invalidateWorktreeContext?.();
-            await refreshGuard.current.run(async () => {
-                const [views] = await Promise.all([
-                    viewReader.readMany(selectedWorkspaceIds),
-                    contextRefresh ?? Promise.resolve(),
-                ]);
-                return views;
-            }, (views) => {
-                setReadState((current) => {
-                    const merged = mergeWorktreeViews(current.views, workspaceIdsRef.current, views);
-                    return {
-                        status: 'ready',
-                        views: modalReadViewRef.current === undefined
-                            ? merged
-                            : mergeWorktreeView(merged, modalReadViewRef.current),
-                    };
-                });
-            }, (error) => {
-                if (preserveCurrent)
-                    throw error;
-                setReadState({
-                    status: 'error',
-                    views: modalReadViewRef.current === undefined ? [] : [modalReadViewRef.current],
-                    error: toWorktreeViewError(error),
-                });
-            });
-            return;
-        }
-        const requestedWorkspaceIds = scope.kind === 'workspace'
-            ? [scope.workspaceId]
-            : scope.workspaceIds;
-        const selectedWorkspaceIds = [...new Set(requestedWorkspaceIds)].filter((workspaceId) => currentWorkspaceIds.includes(workspaceId));
-        if (selectedWorkspaceIds.length === 0)
-            return;
-        await Promise.allSettled(selectedWorkspaceIds.map(async (workspaceId) => {
-            const guard = guardFor(workspaceId);
-            viewReader.invalidate(workspaceId);
-            const contextRefresh = options.invalidateContext === false
-                ? undefined
-                : invalidateWorktreeContext?.(workspaceId);
-            const generation = guard.begin();
-            try {
-                const view = await viewReader.read(workspaceId);
-                if (!guard.isCurrent(generation))
-                    return;
-                if (!workspaceIdsRef.current.includes(workspaceId))
-                    return;
-                setReadState((current) => {
-                    const remainingTargetError = current.targetError?.workspaceIds.filter((candidate) => candidate !== workspaceId) ?? [];
-                    const next = {
-                        ...current,
-                        status: 'ready',
-                        views: mergeWorktreeViews(current.views, workspaceIdsRef.current, [view]),
-                        error: undefined,
-                    };
-                    if (remainingTargetError.length === 0) {
-                        const withoutTargetError = { ...next };
-                        delete withoutTargetError.targetError;
-                        return withoutTargetError;
-                    }
-                    return {
-                        ...next,
-                        targetError: {
-                            workspaceIds: remainingTargetError,
-                            error: current.targetError.error,
-                        },
-                    };
-                });
-            }
-            catch (error) {
-                if (!guard.isCurrent(generation))
-                    return;
-                if (!workspaceIdsRef.current.includes(workspaceId))
-                    return;
-                setReadState((current) => {
-                    const previousIds = current.targetError?.workspaceIds ?? [];
-                    return {
-                        ...current,
-                        status: 'ready',
-                        views: mergeWorktreeViews(current.views, workspaceIdsRef.current, []),
-                        error: undefined,
-                        targetError: {
-                            workspaceIds: [...new Set([...previousIds, workspaceId])],
-                            error: {
-                                ...toWorktreeViewError(error),
-                                retryable: true,
-                            },
-                        },
-                    };
-                });
-            }
-            finally {
-                await contextRefresh?.catch(() => undefined);
-            }
-        }));
-    }, [invalidateWorktreeContext, manager, viewReader]);
-    const loadModalWorktreeView = useCallback((workspaceId) => {
-        setModalReadError(undefined);
-        setModalReadLoading(true);
-        if (manager === undefined) {
-            setModalReadLoading(false);
-            setModalReadError({
-                code: 'WORKTREE_VIEW_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        void modalReadLoader.current.load(workspaceId, (view) => {
-            modalReadViewRef.current = view;
-            setModalReadLoading(false);
-            setReadState((current) => ({
-                ...current,
-                views: mergeWorktreeView(current.views, view),
-            }));
-        }, (error) => {
-            setModalReadLoading(false);
-            setModalReadError(toWorktreeViewError(error));
-        });
-    }, [manager, viewReader]);
-    useEffect(() => {
-        if (mode === 'worktree') {
-            void refresh({ preserveCurrent: readStateRef.current.status === 'ready' });
-        }
-        else {
-            refreshGuard.current.invalidate();
-            for (const guard of targetRefreshGuards.current.values())
-                guard.invalidate();
-            modalReadLoader.current.invalidate();
-            modalReadViewRef.current = undefined;
-            setWorktreeModalWorkspaceId(undefined);
-            setModalReadError(undefined);
-            setModalReadLoading(false);
-            setReadState(EMPTY_READ_STATE);
-        }
-    }, [mode, refresh]);
-    const previousWorkspaceIdsRef = useRef(workspaceIds);
-    useEffect(() => {
-        const previousWorkspaceIds = previousWorkspaceIdsRef.current;
-        previousWorkspaceIdsRef.current = workspaceIds;
-        if (mode !== 'worktree')
-            return;
-        const addedWorkspaceIds = workspaceIds.filter((workspaceId) => !previousWorkspaceIds.includes(workspaceId));
-        const removedWorkspaceIds = previousWorkspaceIds.filter((workspaceId) => !workspaceIds.includes(workspaceId));
-        for (const workspaceId of removedWorkspaceIds) {
-            targetRefreshGuards.current.delete(workspaceId);
-        }
-        setReadState((current) => {
-            const views = mergeWorktreeViews(current.views, workspaceIds, []);
-            const remainingTargetError = current.targetError?.workspaceIds.filter((workspaceId) => workspaceIds.includes(workspaceId)) ?? [];
-            const next = { ...current, views };
-            if (remainingTargetError.length === 0) {
-                const withoutTargetError = { ...next };
-                delete withoutTargetError.targetError;
-                return withoutTargetError;
-            }
-            return {
-                ...next,
-                targetError: {
-                    workspaceIds: remainingTargetError,
-                    error: current.targetError.error,
-                },
-            };
-        });
-        for (const workspaceId of addedWorkspaceIds) {
-            void refresh({
-                scope: { kind: 'workspace', workspaceId },
-                preserveCurrent: true,
-            }).catch(() => {
-                // The target error remains visible and can be retried explicitly.
-            });
-        }
-    }, [mode, refresh, workspaceIds]);
-    useEffect(() => {
-        if (forkRecoveryRevisionRef.current === forkRecoverySnapshot.revision)
-            return;
-        forkRecoveryRevisionRef.current = forkRecoverySnapshot.revision;
-        if (mode !== 'worktree' || manager === undefined)
-            return;
-        if (forkRecoverySnapshot.affectedWorkspaceIds.length === 0)
-            return;
-        void refresh({
-            scope: {
-                kind: 'workspaces',
-                workspaceIds: forkRecoverySnapshot.affectedWorkspaceIds,
-            },
-            preserveCurrent: readStateRef.current.status === 'ready',
-        }).catch(() => {
-            // Recovery state remains visible; the next explicit retry can refresh it again.
-        });
-    }, [
-        forkRecoverySnapshot.affectedWorkspaceIds,
-        forkRecoverySnapshot.revision,
-        manager,
-        mode,
-        refresh,
-    ]);
-    useEffect(() => {
-        if (readState.status !== 'ready' || syncSessionWorkspaces === undefined)
-            return;
-        syncSessionWorkspaces(readState.views.flatMap((view) => view.bindings.map((binding) => ({
-            workspaceId: binding.workspaceId,
-            sessionId: binding.sessionId,
-        }))));
-    }, [readState.status, readState.views, syncSessionWorkspaces]);
-    const viewByWorkspace = useMemo(() => new Map(readState.views.map((view) => [view.workspaceId, view])), [readState.views]);
-    const sessionOrderInputs = useMemo(() => {
-        if (readState.status !== 'ready')
-            return [];
-        const inputs = [];
-        for (const workspace of workspaces.items) {
-            const view = viewByWorkspace.get(workspace.workspaceId);
-            const allWorkspaceSessionIds = filterArchivedSessionIds(workspaceSessionIds(workspaces, workspace.workspaceId, sessions.ids), archivedSessionIds);
-            const bindings = view?.bindings ?? [];
-            const boundSessionIds = new Set(bindings.map((binding) => binding.sessionId));
-            const mainSessionIds = filterVisibleSessionIds(unboundSessionIds(allWorkspaceSessionIds, [...boundSessionIds]), sessions);
-            inputs.push({
-                accountKey: `main:${workspace.workspaceId}`,
-                sessionIds: mainSessionIds,
-                updatedAtById: updatedAtById(mainSessionIds, sessions),
-            });
-            for (const record of view?.worktrees ?? []) {
-                const worktreeSessionIds = filterVisibleSessionIds(filterArchivedSessionIds(bindingIdsFor(bindings, record.worktreeId).filter((sessionId) => sessions.ids.includes(sessionId)), archivedSessionIds), sessions);
-                inputs.push({
-                    accountKey: `worktree:${record.worktreeId}`,
-                    sessionIds: worktreeSessionIds,
-                    updatedAtById: updatedAtById(worktreeSessionIds, sessions),
-                });
-            }
-        }
-        return inputs;
-    }, [
-        archivedSessionIds,
-        readState.status,
-        sessions.byId,
-        sessions.ids,
-        viewByWorkspace,
-        workspaces,
-        workspaces.items,
-    ]);
-    const orderedSessionIdsByAccount = useMemo(() => {
-        const ordered = new Map();
-        for (const input of sessionOrderInputs) {
-            const previous = sessionOrderSnapshot.accounts[input.accountKey];
-            ordered.set(input.accountKey, nextSessionOrderAccount({
-                baseIds: input.sessionIds,
-                updatedAtById: input.updatedAtById,
-                previous,
-            }).order);
-        }
-        return ordered;
-    }, [sessionOrderInputs, sessionOrderSnapshot]);
-    useEffect(() => {
-        if (mode !== 'worktree' || readState.status !== 'ready')
-            return;
-        for (const input of sessionOrderInputs) {
-            sessionOrder.actions.reconcile(input.accountKey, input.sessionIds, input.updatedAtById);
-        }
-        sessionOrder.actions.retain(sessionOrderInputs.map((input) => input.accountKey));
-    }, [mode, readState.status, sessionOrder, sessionOrderInputs]);
-    const currentSessionLocation = useMemo(() => readState.status === 'ready'
-        ? resolveCurrentSessionLocation(currentSessionId, workspaces.items, readState.views)
-        : undefined, [currentSessionId, readState.status, readState.views, workspaces.items]);
-    const currentRevealKeys = useMemo(() => new Set(currentSessionRevealKeys(currentSessionLocation)), [currentSessionLocation]);
-    const isCurrentSessionReveal = (key) => currentSessionReveal !== undefined &&
-        currentSessionReveal.sessionId === currentSessionId &&
-        currentRevealKeys.has(key) &&
-        currentSessionReveal.suppressedKeys[key] !== true;
-    useLayoutEffect(() => {
-        locateGenerationRef.current += 1;
-        positionedLocateGenerationRef.current = undefined;
-        if (mode !== 'worktree') {
-            setCurrentSessionReveal(undefined);
-            return;
-        }
-        if (searchQueryRef.current.trim().length > 0)
-            setSearchQuery('');
-        setCurrentSessionReveal(currentSessionId === undefined
-            ? undefined
-            : { sessionId: currentSessionId, suppressedKeys: {} });
-    }, [currentSessionId, mode]);
-    useLayoutEffect(() => {
-        if (mode !== 'worktree' ||
-            currentSessionId === undefined ||
-            currentSessionLocation === undefined) {
-            return;
-        }
-        const generation = locateGenerationRef.current;
-        if (positionedLocateGenerationRef.current === generation)
-            return;
-        let cancelled = false;
-        const frame = requestAnimationFrame(() => {
-            if (cancelled || generation !== locateGenerationRef.current)
-                return;
-            if (!scrollCurrentSessionIntoView(ref.current, currentSessionId))
-                return;
-            positionedLocateGenerationRef.current = generation;
-        });
-        return () => {
-            cancelled = true;
-            cancelAnimationFrame(frame);
-        };
-    }, [
-        currentSessionId,
-        currentSessionLocation,
-        currentSessionReveal,
-        expandSnapshot,
-        mode,
-        query,
-        readState.status,
-    ]);
-    useEffect(() => {
-        if (readState.status !== 'ready' ||
-            !isCompleteWorktreeWorkspaceSnapshot(workspaceIds, readState.views))
-            return;
-        expandState.actions.retain(workspaceIds, readState.views.flatMap((view) => view.worktrees.map((record) => record.worktreeId)));
-    }, [expandState, readState.status, readState.views, workspaceIds]);
-    const modalWorkspace = workspaces.items.find((workspace) => workspace.workspaceId === worktreeModalWorkspaceId);
-    const modalView = worktreeModalWorkspaceId === undefined
-        ? undefined
-        : 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 = !modalReadLoading && modalSetupStatus === undefined && modalReadiness?.status === 'ready';
-    useEffect(() => {
-        if (worktreeModalWorkspaceId === undefined || modalView === undefined)
-            return;
-        if (modalView.readiness.status !== 'ready') {
-            setSelectedBranch('');
-            setNewBranch('');
-            return;
-        }
-        setSelectedBranch((current) => reconcileBaseBranchSelection(current, modalView.branches));
-        setNewBranch((current) => {
-            if (current.length > 0)
-                return current;
-            const existingNames = [
-                ...modalView.branches.map((branch) => branch.name),
-                ...modalView.worktrees.map((worktree) => worktree.branch),
-            ];
-            return createDefaultWorktreeName(existingNames);
-        });
-    }, [modalView, worktreeModalWorkspaceId]);
-    const runMutation = async (operation, refreshOptions) => {
-        setActionPending(true);
-        setActionError(undefined);
-        try {
-            await operation();
-            if (refreshOptions !== undefined)
-                await refresh(refreshOptions);
-        }
-        catch (error) {
-            setActionError(toWorktreeViewError(error));
-        }
-        finally {
-            setActionPending(false);
-        }
-    };
-    const loadImportCandidates = useCallback(async (workspaceId) => {
-        if (manager === undefined)
-            return;
-        setImportCandidates((current) => ({ status: 'loading', candidates: current.candidates }));
-        await importCandidatesGuard.current.run(() => manager.listImportCandidates({ workspaceId }), (candidates) => {
-            if (modalWorkspaceIdRef.current !== workspaceId)
-                return;
-            setImportCandidates({ status: 'ready', candidates });
-        }, (error) => {
-            if (modalWorkspaceIdRef.current !== workspaceId)
-                return;
-            setImportCandidates((current) => ({
-                status: 'error',
-                candidates: current.candidates,
-                error: toWorktreeViewError(error),
-            }));
-        });
-    }, [manager]);
-    const workspaceRenameTrimmed = workspaceRenameDraft.trim();
-    const workspaceRenameDuplicate = workspaceRenameTarget !== undefined &&
-        workspaceRenameTrimmed.length > 0 &&
-        workspaces.items.some((workspace) => workspace.workspaceId !== workspaceRenameTarget.workspaceId &&
-            workspace.title === workspaceRenameTrimmed);
-    const workspaceRenameBlocked = workspaceRenamePending ||
-        workspaceRenameTarget === undefined ||
-        workspaceRenameTrimmed.length === 0 ||
-        workspaceRenameTrimmed === workspaceRenameTarget?.currentTitle ||
-        workspaceRenameDuplicate;
-    const openWorkspaceRename = (workspace) => {
-        setWorkspaceRenameTarget({
-            workspaceId: workspace.workspaceId,
-            currentTitle: workspace.title,
-        });
-        setWorkspaceRenameDraft(workspace.title);
-        setWorkspaceRenameError(undefined);
-    };
-    const closeWorkspaceRename = () => {
-        if (workspaceRenamePending)
-            return;
-        setWorkspaceRenameTarget(undefined);
-        setWorkspaceRenameError(undefined);
-    };
-    const confirmWorkspaceRename = async () => {
-        const target = workspaceRenameTarget;
-        if (workspaceRenameBlocked || target === undefined)
-            return;
-        if (renameWorkspace === undefined) {
-            setWorkspaceRenameError({
-                code: 'WORKSPACE_RENAME_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setWorkspaceRenamePending(true);
-        setWorkspaceRenameError(undefined);
-        try {
-            await renameWorkspace(target.workspaceId, workspaceRenameTrimmed);
-            setWorkspaceRenameTarget(undefined);
-        }
-        catch (error) {
-            setWorkspaceRenameError(toNativeWorktreeViewError(error));
-        }
-        finally {
-            setWorkspaceRenamePending(false);
-        }
-    };
-    const openWorkspaceDelete = (workspace) => {
-        setWorkspaceDeleteTarget({ workspaceId: workspace.workspaceId, title: workspace.title });
-        setWorkspaceDeleteError(undefined);
-    };
-    const closeWorkspaceDelete = () => {
-        if (workspaceDeletePending)
-            return;
-        setWorkspaceDeleteTarget(undefined);
-        setWorkspaceDeleteError(undefined);
-    };
-    const confirmWorkspaceDelete = async () => {
-        const target = workspaceDeleteTarget;
-        if (target === undefined || workspaceDeletePending)
-            return;
-        if (deleteWorkspace === undefined) {
-            setWorkspaceDeleteError({
-                code: 'WORKSPACE_DELETE_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setWorkspaceDeletePending(true);
-        setWorkspaceDeleteError(undefined);
-        try {
-            await deleteWorkspace(target.workspaceId);
-            setWorkspaceDeleteTarget(undefined);
-        }
-        catch (error) {
-            setWorkspaceDeleteError(toNativeWorktreeViewError(error));
-        }
-        finally {
-            setWorkspaceDeletePending(false);
-        }
-    };
-    const commitWorkspaceDrag = (activeDrag, over) => {
-        if (workspaceDropCommitted.current)
-            return;
-        workspaceDropCommitted.current = true;
-        setWorkspaceDrag(undefined);
-        const rows = workspaces.items;
-        const targetIndex = rows.findIndex((workspace) => workspace.workspaceId === over.workspaceId);
-        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 anchorIndex = beforeWorkspaceId === undefined
-            ? rows.length
-            : rows.findIndex((workspace) => workspace.workspaceId === beforeWorkspaceId);
-        if (beforeWorkspaceId === activeDrag.workspaceId ||
-            anchorIndex === sourceIndex ||
-            anchorIndex === sourceIndex + 1) {
-            return;
-        }
-        if (insertWorkspaceBefore === undefined) {
-            setActionError({
-                code: 'WORKSPACE_ORDER_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setActionError(undefined);
-        void insertWorkspaceBefore(activeDrag.workspaceId, beforeWorkspaceId).catch((error) => {
-            setActionError(toWorktreeViewError(error));
-        });
-    };
-    const commitSessionDrag = (activeDrag, over, sessionIds, workspaceId) => {
-        if (sessionDropCommitted.current)
-            return;
-        sessionDropCommitted.current = true;
-        setSessionDrag(undefined);
-        const targetIndex = sessionIds.indexOf(over.sessionId);
-        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);
-        if (beforeSessionId === activeDrag.sessionId ||
-            anchorIndex === sourceIndex ||
-            anchorIndex === sourceIndex + 1) {
-            return;
-        }
-        if (insertSessionBefore === undefined) {
-            setActionError({
-                code: 'SESSION_ORDER_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setActionError(undefined);
-        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));
-        });
-    };
-    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({
-            scope: { kind: 'workspace', workspaceId },
-            preserveCurrent: true,
-            invalidateContext: false,
-        }))
-            .catch((error) => {
-            setActionError(toRetryableWorktreeOrderError(error));
-        });
-    };
-    const openSessionRename = (sessionId, currentTitle) => {
-        setSessionRenameTarget({ sessionId, currentTitle });
-        setSessionRenameDraft(currentTitle);
-        setSessionRenameError(undefined);
-    };
-    const closeSessionRename = () => {
-        if (sessionRenamePending)
-            return;
-        setSessionRenameTarget(undefined);
-        setSessionRenameError(undefined);
-    };
-    const confirmSessionRename = async () => {
-        const target = sessionRenameTarget;
-        const title = sessionRenameDraft.trim();
-        if (target === undefined || title.length === 0 || sessionRenamePending)
-            return;
-        if (renameSession === undefined) {
-            setSessionRenameError({
-                code: 'SESSION_RENAME_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setSessionRenamePending(true);
-        setSessionRenameError(undefined);
-        try {
-            await renameSession(target.sessionId, title);
-            setSessionRenameTarget(undefined);
-        }
-        catch (error) {
-            setSessionRenameError(toNativeWorktreeViewError(error));
-        }
-        finally {
-            setSessionRenamePending(false);
-        }
-    };
-    const archiveWorktreeSession = async (sessionId) => {
-        if (archiveSession === undefined)
-            return;
-        await runMutation(() => archiveSession(sessionId));
-    };
-    const clearSessionGroups = (groupKeys) => {
-        if (groupKeys.length === 0)
-            return;
-        setExpandedSessionGroups((current) => clearSessionGroupExpansion(current, groupKeys));
-    };
-    const suppressCurrentSessionReveal = (key) => {
-        if (!isCurrentSessionReveal(key))
-            return false;
-        setCurrentSessionReveal((current) => {
-            if (current === undefined || current.sessionId !== currentSessionId)
-                return current;
-            return {
-                ...current,
-                suppressedKeys: { ...current.suppressedKeys, [key]: true },
-            };
-        });
-        return true;
-    };
-    const toggleWorkspace = (workspaceId) => {
-        const persistedExpanded = isWorkspaceExpanded(expandSnapshot, workspaceId);
-        const autoExpanded = isCurrentSessionReveal('workspace:' + workspaceId);
-        const visuallyExpanded = persistedExpanded || autoExpanded;
-        if (visuallyExpanded && autoExpanded) {
-            suppressCurrentSessionReveal('workspace:' + workspaceId);
-        }
-        if (visuallyExpanded && !persistedExpanded) {
-            clearSessionGroups([
-                'main:' + workspaceId,
-                ...(viewByWorkspace.get(workspaceId)?.worktrees.map((record) => record.worktreeId) ?? []).map((worktreeId) => 'worktree:' + worktreeId),
-            ]);
-            return;
-        }
-        expandState.actions.toggleWorkspace(workspaceId);
-        if (visuallyExpanded) {
-            clearSessionGroups([
-                'main:' + workspaceId,
-                ...(viewByWorkspace.get(workspaceId)?.worktrees.map((record) => record.worktreeId) ?? []).map((worktreeId) => 'worktree:' + worktreeId),
-            ]);
-        }
-    };
-    const toggleMain = (workspaceId) => {
-        const persistedExpanded = isMainExpanded(expandSnapshot, workspaceId);
-        const autoExpanded = isCurrentSessionReveal('main:' + workspaceId);
-        const visuallyExpanded = persistedExpanded || autoExpanded;
-        if (visuallyExpanded && autoExpanded) {
-            suppressCurrentSessionReveal('main:' + workspaceId);
-        }
-        if (visuallyExpanded && !persistedExpanded) {
-            clearSessionGroups(['main:' + workspaceId]);
-            return;
-        }
-        expandState.actions.toggleMain(workspaceId);
-        if (visuallyExpanded)
-            clearSessionGroups(['main:' + workspaceId]);
-    };
-    const toggleWorktree = (worktreeId) => {
-        const persistedExpanded = isWorktreeExpanded(expandSnapshot, worktreeId);
-        const autoExpanded = isCurrentSessionReveal('worktree:' + worktreeId);
-        const visuallyExpanded = persistedExpanded || autoExpanded;
-        if (visuallyExpanded && autoExpanded) {
-            suppressCurrentSessionReveal('worktree:' + worktreeId);
-        }
-        if (visuallyExpanded && !persistedExpanded) {
-            clearSessionGroups(['worktree:' + worktreeId]);
-            return;
-        }
-        expandState.actions.toggleWorktree(worktreeId);
-        if (visuallyExpanded)
-            clearSessionGroups(['worktree:' + worktreeId]);
-    };
-    const toggleSessionGroup = (groupKey, autoExpanded) => {
-        const transientExpanded = expandedSessionGroups[groupKey] === true;
-        if (autoExpanded) {
-            suppressCurrentSessionReveal('session-group:' + groupKey);
-            setExpandedSessionGroups((current) => {
-                const next = { ...current };
-                delete next[groupKey];
-                return next;
-            });
-            return;
-        }
-        setExpandedSessionGroups((current) => ({
-            ...current,
-            [groupKey]: !transientExpanded,
-        }));
-    };
-    const closeWorktreeCreator = (force = false) => {
-        if (actionPending && !force)
-            return;
-        modalReadLoader.current.invalidate();
-        modalReadViewRef.current = undefined;
-        importCandidatesGuard.current.invalidate();
-        setWorktreeModalWorkspaceId(undefined);
-        setModalReadError(undefined);
-        setModalReadLoading(false);
-    };
-    const openWorktreeCreator = (workspace, defaults = {}) => {
-        const view = viewByWorkspace.get(workspace.workspaceId);
-        modalReadLoader.current.invalidate();
-        modalReadViewRef.current = undefined;
-        importCandidatesGuard.current.invalidate();
-        setWorktreeModalWorkspaceId(workspace.workspaceId);
-        setWorktreeModalMode('create');
-        setImportCandidates({ status: 'idle', candidates: [] });
-        setSelectedImportPath(undefined);
-        setActionError(undefined);
-        setModalReadError(undefined);
-        setModalReadLoading(false);
-        if (view === undefined) {
-            setSelectedBranch(defaults.baseBranch ?? '');
-            setNewBranch(defaults.newBranch ?? '');
-            loadModalWorktreeView(workspace.workspaceId);
-            return;
-        }
-        setSelectedBranch(defaults.baseBranch ?? selectDefaultBaseBranch(view.branches));
-        setNewBranch(defaults.newBranch ?? createDefaultWorktreeName([
-            ...view.branches.map((branch) => branch.name),
-            ...view.worktrees.map((worktree) => worktree.branch),
-        ]));
-    };
-    const changeWorktreeModalMode = (mode) => {
-        setWorktreeModalMode(mode);
-        if (mode === 'import' &&
-            worktreeModalWorkspaceId !== undefined &&
-            importCandidates.status === 'idle') {
-            void loadImportCandidates(worktreeModalWorkspaceId);
-        }
-    };
-    const continueWorktreeRegistration = async (registeredWorktree) => {
-        closeWorktreeCreator(true);
-        if (createSessionCallback === undefined) {
-            await refresh({
-                scope: { kind: 'workspace', workspaceId: registeredWorktree.workspaceId },
-                preserveCurrent: true,
-            });
-            setActionError({
-                code: 'WORKTREE_REGISTRATION_SESSION_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        const sessionInput = {
-            workspaceId: registeredWorktree.workspaceId,
-            worktreeId: registeredWorktree.worktreeId,
-            cwd: registeredWorktree.absolutePath,
-        };
-        try {
-            await createSessionCallback(sessionInput);
-        }
-        catch (error) {
-            if (error instanceof WorktreeSessionBindingError && error.retryable) {
-                setPendingSessionBinding({ ...sessionInput, sessionId: error.sessionId });
-            }
-            if (error instanceof WorktreeSessionPermissionError && error.retryable) {
-                setPendingSessionBinding({
-                    ...sessionInput,
-                    sessionId: error.sessionId,
-                    permissionRequired: true,
-                });
-            }
-            throw error;
-        }
-        await refresh({
-            scope: { kind: 'workspace', workspaceId: registeredWorktree.workspaceId },
-            preserveCurrent: true,
-        });
-    };
-    const submitWorktree = async () => {
-        const worktreeName = newBranch.trim();
-        const selectedImportCandidate = importCandidates.candidates.find((candidate) => candidate.absolutePath === selectedImportPath);
-        if (manager === undefined || modalWorkspace === undefined)
-            return;
-        if (worktreeModalMode === 'create' &&
-            (!modalCanCreate || selectedBranch.length === 0 || worktreeName.length === 0))
-            return;
-        if (worktreeModalMode === 'import' && selectedImportCandidate === undefined)
-            return;
-        setActionPending(true);
-        setActionError(undefined);
-        setPendingSessionBinding(undefined);
-        try {
-            const registeredWorktree = worktreeModalMode === 'create'
-                ? await executeWorktreeAction(manager, {
-                    type: 'createWorktree',
-                    input: {
-                        workspaceId: modalWorkspace.workspaceId,
-                        branch: selectedBranch,
-                        newBranch: worktreeName,
-                    },
-                })
-                : await executeWorktreeAction(manager, {
-                    type: 'importWorktree',
-                    input: {
-                        workspaceId: modalWorkspace.workspaceId,
-                        absolutePath: selectedImportCandidate.absolutePath,
-                    },
-                });
-            if (registeredWorktree === undefined) {
-                throw {
-                    code: 'WORKTREE_RECORD_MISSING',
-                    message: '',
-                    retryable: true,
-                };
-            }
-            await continueWorktreeRegistration(registeredWorktree);
-        }
-        catch (error) {
-            setActionError(toWorktreeViewError(error));
-        }
-        finally {
-            setActionPending(false);
-        }
-    };
-    const createSession = async (input) => {
-        if (createSessionCallback === undefined) {
-            setActionError({
-                code: 'SESSION_CREATE_UNAVAILABLE',
-                message: '',
-                retryable: true,
-            });
-            return;
-        }
-        setActionPending(true);
-        setActionError(undefined);
-        setPendingSessionBinding(undefined);
-        try {
-            await createSessionCallback(input);
-            await refresh({
-                scope: { kind: 'workspace', workspaceId: input.workspaceId },
-                preserveCurrent: true,
-            });
-        }
-        catch (error) {
-            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 {
-            setActionPending(false);
-        }
-    };
-    const retrySessionBinding = async () => {
-        if (manager === undefined || pendingSessionBinding === undefined || pendingSessionArchived)
-            return;
-        const pending = pendingSessionBinding;
-        setActionPending(true);
-        setActionError(undefined);
-        try {
-            await retryWorktreeSessionBinding({
-                manager,
-                pending,
-                archived: false,
-                ensureSessionWorkspace: (workspaceId, sessionId) => {
-                    ensureSessionWorkspace?.(workspaceId, sessionId);
-                },
-                permission,
-                confirmFullAccess,
-                onPermissionResult,
-                openSession,
-            });
-            setPendingSessionBinding(undefined);
-            await refresh({
-                scope: { kind: 'workspace', workspaceId: pending.workspaceId },
-                preserveCurrent: true,
-            });
-        }
-        catch (error) {
-            if (error instanceof WorktreeSessionBindingError && !error.retryable) {
-                setPendingSessionBinding(undefined);
-            }
-            setActionError(toWorktreeViewError(error));
-        }
-        finally {
-            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);
-    };
-    if (mode !== 'worktree')
+    const lifecycle = useLifecycleActions({ read, lifecycleState, source, props, mutation });
+    if (source.mode !== 'worktree')
         return null;
-    const visibleWorkspaces = workspaces.items.filter((workspace) => workspaceMatches(workspace, viewByWorkspace.get(workspace.workspaceId), sessions, query));
+    const { ref, width, bounds, collapsed } = source;
+    const { t } = props;
     return (_jsxs("aside", { ref: ref, className: styles.surface, "data-worktree-surface": true, "data-collapsed": collapsed || undefined, "aria-label": t('mode.navigation'), style: {
             width: `${width}px`,
             ...(bounds.ready
                 ? { top: `${bounds.top}px`, height: `${bounds.height}px` }
                 : { height: '0px', visibility: 'hidden' }),
-        }, children: [_jsxs("div", { className: styles.wideContent, children: [_jsxs("header", { className: styles.header, children: [_jsx("span", { className: styles.title, children: t('worktree.title') }), _jsx("button", { type: "button", className: styles.closeButton, "aria-label": t('mode.exit'), onClick: () => {
-                                    actions.setViewMode('workspace-session');
-                                }, children: _jsx(IconCloseOutline16, {}) })] }), _jsxs("div", { className: styles.searchRow, children: [_jsx("span", { className: styles.searchIcon, "aria-hidden": "true", children: _jsx(IconSearchOutline16, {}) }), _jsx("input", { className: styles.searchInput, "aria-label": t('workspace.search'), placeholder: t('workspace.search'), value: searchQuery, onChange: (event) => {
-                                    setSearchQuery(event.currentTarget.value);
-                                } }), _jsx("button", { type: "button", className: styles.iconButton, "aria-label": t('workspace.add'), onClick: () => {
-                                    if (createWorkspace !== undefined)
-                                        void runMutation(createWorkspace);
-                                }, 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') }), !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: () => {
-                                            setActionError(undefined);
-                                            void refresh({ scope: { kind: 'global' } });
-                                        }, children: t('action.retry') }))] })), readState.targetError !== undefined && (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-target-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(readState.targetError.error, t) }), _jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
-                                            void refresh({
-                                                scope: {
-                                                    kind: 'workspaces',
-                                                    workspaceIds: readState.targetError.workspaceIds,
-                                                },
-                                                preserveCurrent: true,
-                                            });
-                                        }, 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: () => {
-                                            void refresh({ scope: { kind: 'global' } });
-                                        }, 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 = isWorkspaceExpanded(expandSnapshot, workspace.workspaceId) ||
-                                        isCurrentSessionReveal('workspace:' + workspace.workspaceId);
-                                    const workspaceMatchesQuery = includesText(workspace.title, query);
-                                    const allWorkspaceSessionIds = filterArchivedSessionIds(workspaceSessionIds(workspaces, workspace.workspaceId, sessions.ids), archivedSessionIds);
-                                    const workspaceActivitySessionIds = filterVisibleSessionIds(allWorkspaceSessionIds, sessions);
-                                    const workspaceHasOngoingSession = hasOngoingSession(workspaceActivitySessionIds, sessionPresentations);
-                                    const bindings = view?.bindings ?? [];
-                                    const boundSessionIds = new Set(bindings.map((binding) => binding.sessionId));
-                                    const mainSessionIds = filterVisibleSessionIds(unboundSessionIds(allWorkspaceSessionIds, [...boundSessionIds]), sessions);
-                                    const mainGroupKey = `main:${workspace.workspaceId}`;
-                                    const orderedMainSessionIds = orderedSessionIdsByAccount.get(mainGroupKey) ?? mainSessionIds;
-                                    const visibleMainSessionIds = mainSessionIds.filter((sessionId) => workspaceMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
-                                    const orderedVisibleMainSessionIds = orderedMainSessionIds.filter((sessionId) => workspaceMatchesQuery || sessionMatchesQuery(sessionId, sessions, query));
-                                    const mainExpanded = isMainExpanded(expandSnapshot, workspace.workspaceId) ||
-                                        isCurrentSessionReveal('main:' + workspace.workspaceId);
-                                    const sessionIds = orderedVisibleMainSessionIds.length === visibleMainSessionIds.length
-                                        ? orderedVisibleMainSessionIds
-                                        : visibleMainSessionIds;
-                                    const mainSessionGroupAutoExpanded = isSessionGroupAutoExpanded(sessionIds, currentSessionId, isCurrentSessionReveal('session-group:' + mainGroupKey));
-                                    const mainSessionGroupExpanded = expandedSessionGroups[mainGroupKey] === true ||
-                                        mainSessionGroupAutoExpanded;
-                                    const worktrees = view?.worktrees ?? [];
-                                    const workspaceWorktreeNames = [
-                                        ...(view?.branches.map((branch) => branch.name) ?? []),
-                                        ...(view?.worktrees.map((worktree) => worktree.branch) ?? []),
-                                    ];
-                                    const sameWorkspaceWorktreeDrag = worktreeDrag?.workspaceId === workspace.workspaceId;
-                                    return (_jsxs("section", { className: styles.workspaceGroup, "data-workspace-id": workspace.workspaceId, children: [_jsx(WorktreeWorkspaceRow, { t: t, workspace: workspace, expanded: expanded, hasOngoingSession: workspaceHasOngoingSession, actionPending: actionPending, menuOpen: openWorkspaceMenuId === workspace.workspaceId, drag: {
-                                                    active: workspaceDrag !== undefined,
-                                                    marker: workspaceDrag?.over?.workspaceId === workspace.workspaceId
-                                                        ? workspaceDrag.over.half
-                                                        : null,
-                                                    start: () => {
-                                                        workspaceDropCommitted.current = false;
-                                                        setWorkspaceDrag({ workspaceId: workspace.workspaceId, over: null });
-                                                    },
-                                                    hover: (half) => {
-                                                        setWorkspaceDrag((current) => current === undefined
-                                                            ? current
-                                                            : {
-                                                                ...current,
-                                                                over: { workspaceId: workspace.workspaceId, half },
-                                                            });
-                                                    },
-                                                    drop: (half) => {
-                                                        if (workspaceDrag === undefined)
-                                                            return;
-                                                        commitWorkspaceDrag(workspaceDrag, {
-                                                            workspaceId: workspace.workspaceId,
-                                                            half,
-                                                        });
-                                                    },
-                                                    end: () => {
-                                                        if (workspaceDrag?.over !== null && workspaceDrag?.over !== undefined) {
-                                                            commitWorkspaceDrag(workspaceDrag, workspaceDrag.over);
-                                                        }
-                                                        else {
-                                                            setWorkspaceDrag(undefined);
-                                                        }
-                                                        workspaceDropCommitted.current = false;
-                                                    },
-                                                }, onToggle: () => {
-                                                    toggleWorkspace(workspace.workspaceId);
-                                                }, onCreateWorktree: () => {
-                                                    openWorktreeCreator(workspace);
-                                                }, onRename: () => {
-                                                    openWorkspaceRename(workspace);
-                                                }, onDelete: () => {
-                                                    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, 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, sessionPresentations: sessionPresentations, dragState: sessionDrag, onToggleExpanded: () => {
-                                                            toggleSessionGroup(mainGroupKey, mainSessionGroupAutoExpanded);
-                                                        }, onStartDrag: (groupKey, sessionId) => {
-                                                            sessionDropCommitted.current = false;
-                                                            setSessionDrag({ groupKey, sessionId, over: null });
-                                                        }, onHoverDrag: (sessionId, half) => {
-                                                            setSessionDrag((current) => current === undefined
-                                                                ? current
-                                                                : { ...current, over: { sessionId, half } });
-                                                        }, onClearDrag: () => {
-                                                            setSessionDrag(undefined);
-                                                        }, onFinishDrag: () => {
-                                                            sessionDropCommitted.current = false;
-                                                        }, 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 = 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) => sessionMatchesQuery(sessionId, sessions, query))) {
-                                                            return null;
-                                                        }
-                                                        const visibleWorktreeSessionIds = worktreeSessionIds.filter((sessionId) => worktreeMatchesQuery ||
-                                                            sessionMatchesQuery(sessionId, sessions, query));
-                                                        const worktreeGroupKey = `worktree:${record.worktreeId}`;
-                                                        const orderedWorktreeSessionIds = orderedSessionIdsByAccount.get(worktreeGroupKey) ??
-                                                            worktreeSessionIds;
-                                                        const orderedVisibleWorktreeSessionIds = orderedWorktreeSessionIds.filter((sessionId) => worktreeMatchesQuery ||
-                                                            sessionMatchesQuery(sessionId, sessions, query));
-                                                        const sessionIds = orderedVisibleWorktreeSessionIds.length ===
-                                                            visibleWorktreeSessionIds.length
-                                                            ? orderedVisibleWorktreeSessionIds
-                                                            : visibleWorktreeSessionIds;
-                                                        const sessionGroupAutoExpanded = isSessionGroupAutoExpanded(sessionIds, currentSessionId, isCurrentSessionReveal('session-group:' + worktreeGroupKey));
-                                                        const sessionGroupExpanded = expandedSessionGroups[worktreeGroupKey] === true ||
-                                                            sessionGroupAutoExpanded;
-                                                        const state = record.status === 'removed'
-                                                            ? 'warning'
-                                                            : record.health === 'repair' || record.health === 'recovery-needed'
-                                                                ? 'error'
-                                                                : 'done';
-                                                        const stateLabel = record.status === 'removed'
-                                                            ? t('worktree.detached')
-                                                            : 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, 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' && record.health !== 'recovery-needed'
-                                                                        ? () => {
-                                                                            void createSession({
-                                                                                workspaceId: record.workspaceId,
-                                                                                worktreeId: record.worktreeId,
-                                                                                cwd: record.absolutePath,
-                                                                            });
-                                                                        }
-                                                                        : 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: {
-                                                                        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: 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 });
-                                                                    }, onHoverDrag: (sessionId, half) => {
-                                                                        setSessionDrag((current) => current === undefined
-                                                                            ? current
-                                                                            : { ...current, over: { sessionId, half } });
-                                                                    }, onClearDrag: () => {
-                                                                        setSessionDrag(undefined);
-                                                                    }, onFinishDrag: () => {
-                                                                        sessionDropCommitted.current = false;
-                                                                    }, onCommitDrag: commitSessionDrag, onOpen: (sessionId) => {
-                                                                        openWorkspaceSession(workspace.workspaceId, sessionId);
-                                                                    }, onRename: renameSession === undefined ? undefined : openSessionRename, onFork: forkSession, onArchive: archiveSession === undefined
-                                                                        ? undefined
-                                                                        : archiveWorktreeSession }))] }, record.worktreeId));
-                                                    })] }))] }, workspace.workspaceId));
-                                })) })) : null] })] }), _jsx(WorktreeSessionRenameDialog, { t: t, target: sessionRenameTarget, draft: sessionRenameDraft, pending: sessionRenamePending, error: sessionRenameError, onClose: closeSessionRename, onDraftChange: (draft) => {
-                    setSessionRenameDraft(draft);
-                    setSessionRenameError(undefined);
-                }, onSubmit: confirmSessionRename }), _jsx(WorktreeWorkspaceRenameDialog, { t: t, target: workspaceRenameTarget, draft: workspaceRenameDraft, pending: workspaceRenamePending, duplicate: workspaceRenameDuplicate, error: workspaceRenameError, onClose: closeWorkspaceRename, onDraftChange: (draft) => {
-                    setWorkspaceRenameDraft(draft);
-                    setWorkspaceRenameError(undefined);
-                }, onSubmit: confirmWorkspaceRename }), _jsx(WorktreeWorkspaceDeleteDialog, { t: t, target: workspaceDeleteTarget, pending: workspaceDeletePending, error: workspaceDeleteError, onClose: closeWorkspaceDelete, onSubmit: confirmWorkspaceDelete }), _jsx(WorktreeCreateDialog, { t: t, workspace: modalWorkspace, view: modalView, readError: modalReadError, setupStatus: modalSetupStatus, canCreate: modalCanCreate, mode: worktreeModalMode, importCandidates: importCandidates, selectedImportPath: selectedImportPath, selectedBranch: selectedBranch, newBranch: newBranch, actionPending: actionPending, onClose: closeWorktreeCreator, onRetry: () => {
-                    if (worktreeModalWorkspaceId === undefined)
-                        return;
-                    modalReadViewRef.current = undefined;
-                    setSelectedBranch('');
-                    setNewBranch('');
-                    loadModalWorktreeView(worktreeModalWorkspaceId);
-                }, onModeChange: changeWorktreeModalMode, onRetryImportCandidates: () => {
-                    if (worktreeModalWorkspaceId !== undefined) {
-                        void loadImportCandidates(worktreeModalWorkspaceId);
-                    }
-                }, onSelectedImportPathChange: setSelectedImportPath, onSelectedBranchChange: setSelectedBranch, onNewBranchChange: setNewBranch, onSubmit: submitWorktree }), _jsx(WorktreeRemovalDialog, { t: t, worktree: worktreeRemoval, actionPending: actionPending, onClose: () => {
-                    setWorktreeRemoval(undefined);
-                }, onSubmit: () => {
-                    if (manager === undefined || worktreeRemoval === undefined)
-                        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);
-                        setWorktreeRemoval(undefined);
-                    }, {
-                        scope: { kind: 'workspace', workspaceId: target.workspaceId },
-                        preserveCurrent: true,
-                    });
-                } }), _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'), closeLabel: t('dialog.close'), confirmLabel: t('permission.fullAccessEnable'), acknowledged: fullAccessAcknowledged, onAcknowledgedChange: setFullAccessAcknowledged, onCancel: () => {
-                    setFullAccessAcknowledged(false);
-                    fullAccessConfirmation?.resolve(false);
-                }, onConfirm: () => {
-                    setFullAccessAcknowledged(false);
-                    fullAccessConfirmation?.resolve(true);
-                } })] }));
+        }, children: [_jsxs("div", { className: styles.wideContent, children: [_jsx(SurfaceHeader, { expansion: expansion, props: props, source: source, read: read, mutation: mutation }), _jsx(SurfaceContent, { source: source, props: props, lifecycle: lifecycle, mutation: mutation, session: session, read: read, expansion: expansion, ordering: ordering, drag: drag, menus: menus, registration: registration, native: native, lifecycleState: lifecycleState })] }), _jsx(NativeDialogs, { props: props, native: native }), _jsx(RegistrationDialog, { props: props, registration: registration, registrationState: registrationState, mutation: mutation, read: read }), _jsx(LifecycleDialogs, { props: props, lifecycleState: lifecycleState, mutation: mutation, lifecycle: lifecycle, expansion: expansion, read: read, session: session }), _jsx(AccessConfirmation, { source: source, props: props })] }));
 }
 //# sourceMappingURL=WorktreeSurface.js.map