@parhelia/core 0.1.12602 → 0.1.12614

package/dist/editor/client/EditorShell.js

@@ -1,15 +1,17 @@
 "use client";
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useState, useEffect, useRef, useCallback, useSyncExternalStore, useMemo, startTransition, } from "react";
 import { toast } from "sonner";
-import { EditContextProvider, FieldsEditContextProvider, OperationsContextProvider, } from "./editContext";
+import { EditContextProvider, FieldsEditContextProvider, OperationsContextProvider, useEditContext, } from "./editContext";
 import { fieldModificationStore } from "./fieldModificationStore";
-import { useRouter, useSearchParams, usePathname } from "next/navigation";
+import { useRouter, useSearchParams, usePathname } from "./navigation";
 import { findComponent, getComponentById } from "../componentTreeHelper";
 import { getOperationsContext } from "./operations";
 import { handleErrorResult } from "./helpers";
-import { executeFieldAction as executeFieldServerAction, connectSocket, getEditHistory, getRunningOperations, releaseFieldLocks, validateItems, } from "../services/editService";
+import { executeFieldAction as executeFieldServerAction, connectSocket, getEditHistory, getRunningOperations, reconnectSession, releaseFieldLocks, validateItems, } from "../services/editService";
 import { useEditorWebSocket } from "./hooks/useEditorWebSocket";
+import { createEditorSocketDiagnostics, } from "./socketDiagnostics";
+import { localStorageService } from "../services/localStorageService";
 import { useSocketMessageHandler } from "./hooks/useSocketMessageHandler";
 import "react-json-view-lite/dist/index.css";
 import { MediaSelector, } from "../media-selector/MediaSelector";
@@ -19,7 +21,9 @@ import ConfirmationDialog from "../ConfirmationDialog";
 import { getItemDescriptor } from "../utils";
 import { EditContextMenu } from "../ContextMenu";
 import { InlineAiTrigger } from "../ai/InlineAiTrigger";
+import { EditorFormHintPopover } from "../page-viewer/EditorFormHintPopover";
 import { FieldEditorPopup } from "../FieldEditorPopup";
+import { ConcurrentUserLimitDialog } from "../ConcurrentUserLimitDialog";
 import { post } from "../services/serviceHelper";
 import { PageViewerFrame } from "../page-viewer/PageViewerFrame";
 import { useItemsRepository } from "./itemsRepository";
@@ -33,6 +37,7 @@ import { GuidanceOverlay } from "../ai/GuidanceOverlay";
 import { AgentDialogHandler } from "../ai/dialogs";
 import { usePageViewContext, } from "../page-viewer/pageViewContext";
 import { QuickItemSwitcher } from "../QuickItemSwitcher";
+import { useEditorSlotContext, } from "../views/editorSlotContext";
 import { getComments, getAvailableCommentTags, } from "../services/reviewsService";
 import { useReviews } from "../reviews/useReviews";
 import uuid from "react-uuid";
@@ -49,7 +54,38 @@ import { useWorkbox } from "./hooks/useWorkbox";
 import { useMediaSelector } from "./hooks/useMediaSelector";
 import { useGlobalEditorKeyDown } from "./hooks/useGlobalEditorKeyDown";
 import { useStartupChecks } from "../settings/status/index";
-export function EditorShell({ configuration, className, item: loadItemDescriptor, sessionId, userInfo, userPreferences, parheliaSettings, setUserPreferences, children, }) {
+import { FeatureGate, LicenseFeatures, LicenseProvider, LicenseOverlay, } from "../../licensing";
+// Sentinel written to the `sidebar` URL param when the user has explicitly closed
+// every sidebar. Distinguishes "no preference yet" (param absent) from "user wants
+// nothing open" (param present with this value) so reload can honor the user's intent.
+const SIDEBAR_NONE_SENTINEL = "none";
+const sidebarUrlValue = (ids) => ids.length ? ids.join(",") : SIDEBAR_NONE_SENTINEL;
+function AgentsSlotContextBridge({ slot }) {
+    const editContext = useEditContext();
+    const slotContext = useEditorSlotContext({
+        slotId: slot.slotId,
+        itemDescriptor: slot.itemDescriptor,
+        refreshToken: slot.refreshToken,
+    });
+    if (!editContext || !slotContext)
+        return null;
+    useEffect(() => {
+        editContext.registerSlotContext(slot.slotId, slotContext);
+        return () => {
+            editContext.unregisterSlotContext(slot.slotId);
+        };
+    }, [
+        slot.slotId,
+        slotContext,
+        editContext.registerSlotContext,
+        editContext.unregisterSlotContext,
+    ]);
+    return null;
+}
+function AgentsSlotContextBridgeHost({ slots }) {
+    return (_jsx(_Fragment, { children: slots.map((slot) => (_jsx(AgentsSlotContextBridge, { slot: slot }, `agents-slot-bridge-${slot.slotId}`))) }));
+}
+export function EditorShell({ configuration, className, item: loadItemDescriptor, sessionId, userInfo, userPreferences, initialLicenseStatus, initialLicenseStatusLoaded, parheliaSettings, setUserPreferences, children, }) {
     const router = useRouter();
     const pathname = usePathname();
     const searchParams = useSearchParams();
@@ -97,6 +133,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [historyMode, setHistoryMode] = useState("global");
     const [showOnlyMyChanges, setShowOnlyMyChanges] = useState(true);
     const [filterByCurrentLanguage, setFilterByCurrentLanguage] = useState(true);
+    const [historySearchQuery, setHistorySearchQuery] = useState("");
     const [recentEdits, setRecentEdits] = useState([]);
     const addRecentEdit = useCallback((edit) => {
         setRecentEdits((prevEditedFields) => {
@@ -124,14 +161,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     if (typeof window !== "undefined")
         sessionStorage?.setItem("sessionId", sessionId);
     // Workspace state
-    // Note: "reviews" is a sidebar, not a workspace. If view/workspace=reviews, we should
+    // Note: "reviews" is a sidebar, not a workspace. If workspace=reviews, we should
     // set workspace to "editor" and open the reviews sidebar instead.
     // Memoize searchParams reads to avoid triggering Router state updates during render
     // (Next.js App Router uses startTransition internally for URL changes)
-    const rawWorkspace = useMemo(() => searchParams.get("workspace") ?? searchParams.get("view"), [searchParams]);
+    const rawWorkspace = useMemo(() => searchParams.get("workspace"), [searchParams]);
     const isReviewsSidebarRequest = rawWorkspace === "reviews";
     const [workspaceId, setWorkspaceId] = useState(
-    // If view=reviews, use "editor" workspace (reviews is a sidebar, not a workspace)
+    // If workspace=reviews, use "editor" workspace (reviews is a sidebar, not a workspace)
     isReviewsSidebarRequest
         ? "editor"
         : (rawWorkspace ??
@@ -147,13 +184,17 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [openSidebars, setOpenSidebars] = useState(() => {
         const sidebarParam = searchParams.get("sidebar");
         let sidebars = [];
-        if (sidebarParam) {
-            sidebars = sidebarParam.split(",").filter(Boolean);
+        // Presence check (not truthiness) so the sentinel "none" is respected across reloads.
+        if (sidebarParam !== null) {
+            sidebars =
+                sidebarParam === SIDEBAR_NONE_SENTINEL
+                    ? []
+                    : sidebarParam.split(",").filter(Boolean);
         }
         else {
             sidebars = [...(configuration.editor.defaultOpenSidebars ?? [])];
         }
-        // If view/workspace=reviews was requested, ensure reviews sidebar is open
+        // If workspace=reviews was requested, ensure reviews sidebar is open
         if (isReviewsSidebarRequest && !sidebars.includes("reviews")) {
             sidebars.push("reviews");
         }
@@ -161,17 +202,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     });
     // Toolbar pinned sidebars - icons always visible in toolbar (defined early so callbacks can access)
     const [pinnedSidebars, setPinnedSidebars] = useState(userInfo.preferences?.pinnedSidebars || []);
+    const pinnedSidebarsRef = useRef(pinnedSidebars);
     // Locked sidebars - open panels that stay visible when selecting another sidebar
     const [lockedSidebars, setLockedSidebars] = useState(() => {
-        if (typeof window === "undefined") {
-            return [];
-        }
         try {
-            const stored = window.localStorage.getItem("editor.lockedSidebars");
-            if (!stored) {
-                return [];
-            }
-            const parsed = JSON.parse(stored);
+            const parsed = localStorageService.getOrSetItem("editor.lockedSidebars", []);
             if (!Array.isArray(parsed) ||
                 !parsed.every((id) => typeof id === "string")) {
                 return [];
@@ -187,6 +222,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     useEffect(() => {
         lockedSidebarsRef.current = lockedSidebars;
     }, [lockedSidebars]);
+    useEffect(() => {
+        pinnedSidebarsRef.current = pinnedSidebars;
+    }, [pinnedSidebars]);
     // Filter locked sidebars to only include currently open sidebars
     useEffect(() => {
         const openSet = new Set(openSidebars);
@@ -248,15 +286,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     // Group open sidebars into vertical stacks (each stack shares one left column).
     const [sidebarStacks, setSidebarStacks] = useState(() => {
         const defaultStacks = openSidebars.map((id) => [id]);
-        if (typeof window === "undefined") {
-            return normalizeSidebarStacks(openSidebars, defaultStacks);
-        }
         try {
-            const stored = window.localStorage.getItem("editor.sidebarStacks");
-            if (!stored) {
+            const parsed = localStorageService.getItem("editor.sidebarStacks");
+            if (!parsed) {
                 return normalizeSidebarStacks(openSidebars, defaultStacks);
             }
-            const parsed = JSON.parse(stored);
             if (!Array.isArray(parsed) ||
                 !parsed.every((x) => Array.isArray(x) && x.every((id) => typeof id === "string"))) {
                 return normalizeSidebarStacks(openSidebars, defaultStacks);
@@ -278,28 +312,19 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     }, [openSidebars, normalizeSidebarStacks]);
     // Persist stacks independently of the URL (user layout preference).
     useEffect(() => {
-        if (typeof window === "undefined")
-            return;
         try {
-            window.localStorage.setItem("editor.sidebarStacks", JSON.stringify(sidebarStacks));
+            localStorageService.setItem("editor.sidebarStacks", sidebarStacks);
         }
         catch { }
     }, [sidebarStacks]);
     // Persist locked sidebars to localStorage.
     useEffect(() => {
-        if (typeof window === "undefined")
-            return;
         try {
-            window.localStorage.setItem("editor.lockedSidebars", JSON.stringify(lockedSidebars));
+            localStorageService.setItem("editor.lockedSidebars", lockedSidebars);
         }
         catch { }
     }, [lockedSidebars]);
-    // Legacy aliases for backwards compatibility
     const viewName = workspaceId;
-    const setViewName = setWorkspaceId;
-    const viewNameRef = workspaceIdRef;
-    const previousViewName = previousWorkspaceId;
-    const setPreviousViewName = setPreviousWorkspaceId;
     const [compareMode, setCompareModeState] = useState(false);
     const [componentDesignerComponent, setComponentDesignerComponent] = useState();
     const [componentDesignerRendering, setComponentDesignerRendering] = useState();
@@ -307,6 +332,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [ignoreBlur, setIgnoreBlur] = useState(false);
     const [currentItemDescriptor, setCurrentItemDescriptor] = useState();
     const currentItemDescriptorRef = useRef(undefined);
+    const latestGlobalLoadKeyRef = useRef(null);
     const [editorSlots, setEditorSlots] = useState(() => {
         // Always start with empty slots - don't persist the number of slots
         return [];
@@ -326,6 +352,29 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         activeSlotIdRef.current = activeSlotId;
     }, [activeSlotId]);
     const [slotContexts, setSlotContexts] = useState(() => new Map());
+    const promptSessionReconnect = useCallback((reason) => {
+        const description = reason && reason !== "session-revoked"
+            ? `${reason}. Click reconnect to continue in this browser.`
+            : "You were disconnected because this account is active in another browser.";
+        toast.error("Session disconnected", {
+            id: "session-revoked",
+            description,
+            action: {
+                label: "Reconnect",
+                onClick: async () => {
+                    const result = await reconnectSession(sessionId);
+                    if (result.type === "success") {
+                        window.location.reload();
+                        return;
+                    }
+                    toast.error("Reconnect failed", {
+                        description: "Could not claim this browser session. Try again.",
+                    });
+                },
+            },
+            duration: Infinity,
+        });
+    }, [sessionId]);
     // Track previous item ID to detect actual navigation between pages
     const previousItemIdRef = useRef(undefined);
     useEffect(() => {
@@ -354,10 +403,18 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     // Ref to track when we're handling a popstate event (browser back/forward)
     // This prevents the URL sync effect from pushing new history entries during back navigation
     const isHandlingPopStateRef = useRef(false);
-    // Ref to track the last known URL for the popstate handler
-    // This is updated both when the popstate handler runs AND when the URL sync effect pushes a new URL
-    // Without this, the popstate handler would have a stale lastUrl value after pushState calls
-    const lastUrlRef = useRef(typeof window !== "undefined" ? window.location.href : "");
+    // When switchWorkspace already pushed a URL entry, the follow-up URL sync
+    // effect should only *replace* that entry (not push a second one).
+    const switchWorkspacePushedRef = useRef(false);
+    // Ref to track the last known URL for the popstate handler.
+    // Uses pathname+search (not full href) so comparisons are consistent with the
+    // relative URLs produced by the URL sync effect and updateUrl.
+    const lastUrlRef = useRef(typeof window !== "undefined"
+        ? `${window.location.pathname}${window.location.search}`
+        : "");
+    // The very first URL sync after initial load should replaceState (not pushState)
+    // so the initial bare URL isn't left as a dead-end history entry.
+    const isFirstUrlSyncRef = useRef(true);
     const [inlineEditingFieldElement, setInlineEditingFieldElement] = useState();
     const [lockedField, setLockedField] = useState();
     const [itemLanguages, setItemLanguages] = useState([]);
@@ -370,26 +427,16 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [showSuggestedEditsDiff, setShowSuggestedEditsDiff] = useState(false);
     const [availableCommentTags, setAvailableCommentTags] = useState([]);
     const [showComments, setShowComments] = useState(() => {
-        const savedShowComments = typeof window !== "undefined"
-            ? localStorage.getItem("editor.showComments")
-            : null;
-        return savedShowComments ? JSON.parse(savedShowComments) : true;
+        return localStorageService.getOrSetItem("editor.showComments", true);
     });
     useEffect(() => {
-        if (typeof window !== "undefined") {
-            localStorage.setItem("editor.showComments", JSON.stringify(showComments));
-        }
+        localStorageService.setItem("editor.showComments", showComments);
     }, [showComments]);
     const [showResolvedComments, setShowResolvedComments] = useState(() => {
-        const saved = typeof window !== "undefined"
-            ? localStorage.getItem("editor.showResolvedComments")
-            : null;
-        return saved ? JSON.parse(saved) : false;
+        return localStorageService.getOrSetItem("editor.showResolvedComments", false);
     });
     useEffect(() => {
-        if (typeof window !== "undefined") {
-            localStorage.setItem("editor.showResolvedComments", JSON.stringify(showResolvedComments));
-        }
+        localStorageService.setItem("editor.showResolvedComments", showResolvedComments);
     }, [showResolvedComments]);
     const [selectedComment, setSelectedComment] = useState();
     const [browseHistory, setBrowseHistory] = useState(() => {
@@ -408,13 +455,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             visitedAt: entry.visitedAt,
         }));
     });
-    // Navigation history for browser history (view + item combinations)
+    // Navigation history for browser history (workspace + item combinations)
     const [navigationHistory, setNavigationHistory] = useState(() => {
-        // Initialize from browse history with current view
+        // Initialize from browse history with the current workspace
         if (!userInfo.browseHistory)
             return [];
         const defaultWorkspaceId = searchParams.get("workspace") ??
-            searchParams.get("view") ??
             configuration.editor.defaultWorkspace ??
             configuration.editor.workspaces?.[0]?.id ??
             "editor";
@@ -446,20 +492,47 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const [statusMessage, setStatusMessage] = useState("");
     const [focusFieldComponentId, setFocusFieldComponentId] = useState();
     const [enableCompletions, setEnableCompletions] = useState(false);
-    const [showComponentNavigator, setShowComponentNavigator] = useState(userPreferences.showComponentNavigator ?? false);
+    const [showComponentNavigatorDefault, setShowComponentNavigatorDefault] = useState(userPreferences.showComponentNavigator ?? false);
+    const [slotComponentNavigatorVisibility, setSlotComponentNavigatorVisibility] = useState({});
+    useEffect(() => {
+        setSlotComponentNavigatorVisibility((prev) => {
+            const next = {};
+            let changed = false;
+            for (const slot of editorSlots) {
+                if (Object.prototype.hasOwnProperty.call(prev, slot.slotId)) {
+                    next[slot.slotId] = prev[slot.slotId];
+                }
+                else {
+                    next[slot.slotId] = showComponentNavigatorDefault;
+                    changed = true;
+                }
+            }
+            if (Object.keys(prev).length !== editorSlots.length) {
+                changed = true;
+            }
+            return changed ? next : prev;
+        });
+    }, [editorSlots, showComponentNavigatorDefault]);
     const [showAgentsPanel, setShowAgentsPanel] = useState(userPreferences.showAgentsPanel ?? false);
+    const [editorFormHidden, setEditorFormHiddenState] = useState(userPreferences.editorFormHidden ?? false);
+    const [editorFormHintSeen, setEditorFormHintSeenState] = useState(userPreferences.editorFormHintSeen ?? false);
+    const [editorFormHintVisible, setEditorFormHintVisible] = useState(false);
+    const editorFormToggleButtonRef = useRef(null);
     const [showMinimap, setShowMinimap] = useState(userPreferences.showMinimap ?? true);
     const [showHelpTerminal, setShowHelpTerminal] = useState(false);
     const [helpTerminalInitialPrompt, setHelpTerminalInitialPrompt] = useState(undefined);
     const [helpTerminalProfileName, setHelpTerminalProfileName] = useState(undefined);
     const [helpTerminalActiveTab, setHelpTerminalActiveTab] = useState(undefined);
-    const [showAgentsWorkspaceEditor, setShowAgentsWorkspaceEditor] = useState(true);
+    const [selectedHelpSectionId, setSelectedHelpSectionId] = useState(null);
+    const [showAgentsWorkspaceEditor, setShowAgentsWorkspaceEditor] = useState(false);
+    const [selectedAgentsWorkspaceAgentId, setSelectedAgentsWorkspaceAgentId] = useState(null);
     const [activeEditorTab, setActiveEditorTab] = useState(null);
     const [showLayoutComponents, setShowLayoutComponents] = useState(userPreferences.showLayoutComponents ?? false);
     const { quotaInfo, setQuotaInfo, isQuotaExceeded, getQuotaWarningMessage } = useQuota({
         showError: ({ summary, details }) => showErrorToast({ summary, details }),
     });
     const [webSocketMessages, setWebSocketMessages] = useState([]);
+    const [socketDiagnostics, setSocketDiagnostics] = useState(() => createEditorSocketDiagnostics(sessionId));
     const [favorites, setFavorites] = useState([]);
     // Quick item switcher state
     const [quickSwitcherVisible, setQuickSwitcherVisible] = useState(false);
@@ -477,13 +550,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         if (!startupChecks.hasBlockingIssues)
             return;
         // Don't redirect if already in settings workspace - let user navigate freely within settings
-        const currentWorkspace = searchParams.get("workspace") ?? searchParams.get("view");
+        const currentWorkspace = searchParams.get("workspace");
         if (currentWorkspace === "settings")
             return;
         // Redirect to the status panel (where user can see all issues and navigate to fixes)
         const url = new URL(window.location.href);
         url.searchParams.set("workspace", "settings");
-        url.searchParams.delete("view"); // Remove legacy param
         url.searchParams.set("ccpanel", "status");
         router.push(url.toString(), { scroll: false });
     }, [
@@ -501,6 +573,16 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             setMode(queryMode);
         }
     }, [searchParams, isInitialLoad]);
+    useEffect(() => {
+        if (!isInitialLoad)
+            return;
+        const helpParam = searchParams.get("help");
+        if (helpParam) {
+            setHelpTerminalActiveTab("manual");
+            setShowHelpTerminal(true);
+            setSelectedHelpSectionId(helpParam === "contents" || helpParam === "true" ? null : helpParam);
+        }
+    }, [searchParams, isInitialLoad]);
     useEffect(() => {
         if (mode === "suggestions") {
             // Ensure we're in the editor workspace and open the feedback sidebar
@@ -547,12 +629,19 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setSlotContexts((prev) => {
             if (!prev.has(slotId))
                 return prev;
+            if (slotId === activeSlotIdRef.current) {
+                const activeCtx = prev.get(slotId);
+                if (activeCtx) {
+                    lastActiveSlotContextRef.current = activeCtx;
+                }
+            }
             const next = new Map(prev);
             next.delete(slotId);
             return next;
         });
     }, []);
     const slotContextsRef = useRef(slotContexts);
+    const lastActiveSlotContextRef = useRef(null);
     useEffect(() => {
         slotContextsRef.current = slotContexts;
     }, [slotContexts]);
@@ -578,6 +667,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const activeSlotContext = activeSlotId
         ? slotContexts.get(activeSlotId)
         : undefined;
+    const isComponentNavigatorOpenForSlot = useCallback((slotId) => {
+        if (!slotId)
+            return showComponentNavigatorDefault;
+        return (slotComponentNavigatorVisibility[slotId] ?? showComponentNavigatorDefault);
+    }, [slotComponentNavigatorVisibility, showComponentNavigatorDefault]);
+    const showComponentNavigator = isComponentNavigatorOpenForSlot(activeSlotId);
     // Sync global compareMode from the active slot's compareMode for URL syncing
     useEffect(() => {
         if (activeSlotContext && activeSlotContext.compareMode !== compareMode) {
@@ -625,6 +720,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const isItemUsedInCurrentPage = useCallback((item) => pageItemsSetRef.current.has(makeItemKey(item)), [makeItemKey]);
     const socketMessageListeners = useRef(new Set());
     const [socketConnectionVersion, setSocketConnectionVersion] = useState(0);
+    useEffect(() => {
+        setSocketDiagnostics(createEditorSocketDiagnostics(sessionId));
+    }, [sessionId]);
     const addSocketMessageListener = useCallback((callback) => {
         socketMessageListeners.current.add(callback);
         return () => socketMessageListeners.current.delete(callback);
@@ -670,7 +768,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             catch { }
         };
     }, [addSocketMessageListener]);
+    const shouldLoadReviews = openSidebars.includes("reviews") ||
+        workspaceId === "reviews" ||
+        workspaceId === "comments";
     const reviews = useReviews({
+        enabled: shouldLoadReviews,
         currentItemDescriptor,
         addSocketMessageListener: addSocketMessageListener,
     });
@@ -709,8 +811,13 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         console.error(`No workspace found for id: ${workspaceId}`);
         return null;
     }
-    // Legacy alias for backwards compatibility
-    const currentView = currentWorkspace;
+    const activeKeyboardCommands = useMemo(() => {
+        const activeCommandIds = new Set(currentWorkspace.keyboardCommandIds ?? []);
+        return (configuration.commands.keyboardCommands ?? []).filter((command) => activeCommandIds.has(command.id));
+    }, [
+        currentWorkspace.keyboardCommandIds,
+        configuration.commands.keyboardCommands,
+    ]);
     useEffect(() => {
         if (currentWorkspace?.component) {
             setCenterPanelView(currentWorkspace.component);
@@ -738,6 +845,45 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const sendClientInfo = useCallback(() => {
         debouncedSendClientInfo();
     }, [debouncedSendClientInfo]);
+    const getCurrentHistoryState = useCallback(() => {
+        if (typeof window === "undefined") {
+            return null;
+        }
+        return window.history.state;
+    }, []);
+    useEffect(() => {
+        if (isInitialLoad) {
+            return;
+        }
+        const itemid = searchParams.get("itemid");
+        const language = searchParams.get("lang") ?? searchParams.get("language");
+        const versionParam = searchParams.get("version");
+        const version = versionParam ? parseInt(versionParam, 10) : 0;
+        const itemId = cleanId(itemid ?? undefined);
+        if (!itemId || !language) {
+            return;
+        }
+        const currentDescriptor = currentItemDescriptorRef.current;
+        const matchesCurrentDescriptor = currentDescriptor?.id === itemId &&
+            currentDescriptor?.language === language &&
+            (!version || currentDescriptor?.version === version);
+        if (matchesCurrentDescriptor) {
+            return;
+        }
+        isHandlingPopStateRef.current = true;
+        loadItemRef
+            .current({
+            id: itemId,
+            language,
+            version,
+        }, {
+            addToBrowseHistory: false,
+            skipViewChange: true,
+        })
+            .finally(() => {
+            isHandlingPopStateRef.current = false;
+        });
+    }, [isInitialLoad, searchParams]);
     const startTour = useCallback(() => {
         setIsTourActive(true);
         // Persist tour state to URL so it survives navigation/remounts
@@ -745,32 +891,61 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         const params = new URLSearchParams(window.location.search);
         params.set("tour", "active");
         const newUrl = `${window.location.pathname}?${params.toString()}`;
-        window.history.replaceState(null, "", newUrl);
+        window.history.replaceState(getCurrentHistoryState(), "", newUrl);
     }, [setIsTourActive]);
-    const isMobile = useMediaQuery("(max-width: 768px)");
-    const handleSetShowComponentNavigator = useCallback((value) => {
-        const newValue = typeof value === "function" ? value(showComponentNavigator) : value;
-        setShowComponentNavigator(newValue);
+    const isMobile = useMediaQuery("(max-width: 767px)");
+    // On mobile, clear all locked sidebars and keep only the last-opened panel.
+    // Handles viewport resize: desktop -> mobile unlocks everything and trims to one panel.
+    useEffect(() => {
+        if (isMobile) {
+            setLockedSidebars([]);
+            const current = openSidebarsRef.current;
+            const lastSidebar = current[current.length - 1];
+            if (current.length > 1 && lastSidebar) {
+                const trimmed = [lastSidebar];
+                openSidebarsRef.current = trimmed;
+                setOpenSidebars(trimmed);
+            }
+        }
+    }, [isMobile]);
+    const setComponentNavigatorOpenForSlot = useCallback((slotId, value) => {
+        const previousValue = isComponentNavigatorOpenForSlot(slotId);
+        const newValue = typeof value === "function" ? value(previousValue) : value;
+        if (slotId) {
+            setSlotComponentNavigatorVisibility((prev) => {
+                const currentValue = prev[slotId] ?? showComponentNavigatorDefault;
+                if (currentValue === newValue && prev[slotId] !== undefined) {
+                    return prev;
+                }
+                return {
+                    ...prev,
+                    [slotId]: newValue,
+                };
+            });
+        }
+        setShowComponentNavigatorDefault(newValue);
         setUserPreferences({ showComponentNavigator: newValue });
-        // On mobile, close Agents Panel when opening Component Navigator
         if (isMobile && newValue) {
             setShowAgentsPanel(false);
             setUserPreferences({ showAgentsPanel: false });
         }
     }, [
-        showComponentNavigator,
-        setShowComponentNavigator,
+        isComponentNavigatorOpenForSlot,
+        showComponentNavigatorDefault,
         setUserPreferences,
         isMobile,
         setShowAgentsPanel,
     ]);
+    const handleSetShowComponentNavigator = useCallback((value) => {
+        setComponentNavigatorOpenForSlot(activeSlotIdRef.current, value);
+    }, [setComponentNavigatorOpenForSlot]);
     const handleSetShowAgentsPanel = useCallback((value) => {
         const newValue = typeof value === "function" ? value(showAgentsPanel) : value;
         setShowAgentsPanel(newValue);
         setUserPreferences({ showAgentsPanel: newValue });
         // On mobile, close Component Navigator when opening Agents Panel
         if (isMobile && newValue) {
-            setShowComponentNavigator(false);
+            setComponentNavigatorOpenForSlot(activeSlotIdRef.current, false);
             setUserPreferences({ showComponentNavigator: false });
         }
     }, [
@@ -778,13 +953,65 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setShowAgentsPanel,
         setUserPreferences,
         isMobile,
-        setShowComponentNavigator,
+        setComponentNavigatorOpenForSlot,
     ]);
+    // Mobile editor panel state (EditorForm shown in bottom panel on mobile)
+    const [mobileEditorPanelOpen, setMobileEditorPanelOpenRaw] = useState(false);
+    const [dismissedMobilePanelToken, setDismissedMobilePanelToken] = useState(null);
+    const previousActiveSlotIdRef = useRef(null);
+    const mobilePanelDismissToken = useMemo(() => {
+        const selectionKey = selection.join(",");
+        return [
+            activeSlotId || "no-slot",
+            selectionKey,
+            insertMode ? "insert" : "browse",
+        ].join("|");
+    }, [activeSlotId, insertMode, selection]);
+    useEffect(() => {
+        const previousActiveSlotId = previousActiveSlotIdRef.current;
+        if (previousActiveSlotId !== activeSlotId) {
+            setDismissedMobilePanelToken(null);
+        }
+        previousActiveSlotIdRef.current = activeSlotId;
+    }, [activeSlotId]);
+    const handleSetMobileEditorPanelOpen = useCallback((open) => {
+        setMobileEditorPanelOpenRaw(open);
+        if (!open) {
+            setDismissedMobilePanelToken(mobilePanelDismissToken);
+            return;
+        }
+        setDismissedMobilePanelToken(null);
+        if (open && isMobile) {
+            // Close all sidebars when opening the editor panel on mobile
+            openSidebarsRef.current = [];
+            setOpenSidebars([]);
+        }
+    }, [isMobile, mobilePanelDismissToken]);
     const handleSetShowMinimap = useCallback((value) => {
         const newValue = typeof value === "function" ? value(showMinimap) : value;
         setShowMinimap(newValue);
         setUserPreferences({ showMinimap: newValue });
     }, [showMinimap, setUserPreferences]);
+    const handleSetEditorFormHidden = useCallback((value) => {
+        setEditorFormHiddenState(value);
+        setUserPreferences({ editorFormHidden: value });
+    }, [setUserPreferences]);
+    const markEditorFormHintSeen = useCallback(() => {
+        setEditorFormHintSeenState(true);
+        setUserPreferences({ editorFormHintSeen: true });
+    }, [setUserPreferences]);
+    const showEditorFormHint = useCallback(() => {
+        setEditorFormHintVisible(true);
+    }, []);
+    const dismissEditorFormHint = useCallback(() => {
+        setEditorFormHintVisible(false);
+        setEditorFormHintSeenState((prev) => {
+            if (prev)
+                return prev;
+            setUserPreferences({ editorFormHintSeen: true });
+            return true;
+        });
+    }, [setUserPreferences]);
     const handleSetShowHelpTerminal = useCallback((value) => {
         const newValue = typeof value === "function" ? value(showHelpTerminal) : value;
         setShowHelpTerminal(newValue);
@@ -793,6 +1020,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             setHelpTerminalInitialPrompt(undefined);
             setHelpTerminalProfileName(undefined);
             setHelpTerminalActiveTab(undefined);
+            setSelectedHelpSectionId(null);
         }
     }, [showHelpTerminal]);
     const toggleHelpTerminal = useCallback((options) => {
@@ -835,13 +1063,27 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setOpenSidebars(newOrder);
         setSidebarStacks((prev) => normalizeSidebarStacks(newOrder, prev));
     }, []);
+    const ensureSidebarPinned = useCallback((sidebarId) => {
+        const currentPinnedSidebars = pinnedSidebarsRef.current;
+        if (currentPinnedSidebars.includes(sidebarId)) {
+            return;
+        }
+        const newPinnedSidebars = [...currentPinnedSidebars, sidebarId];
+        pinnedSidebarsRef.current = newPinnedSidebars;
+        setPinnedSidebars(newPinnedSidebars);
+        setUserPreferences({ pinnedSidebars: newPinnedSidebars });
+    }, [setUserPreferences]);
     // messageHandler is defined after loadItem/loadHistory declarations to avoid temporal dead zones
     const user = activeSessions.find((x) => x.sessionId === sessionId)?.user ||
         userInfo.user;
-    // Self-heal if our session disappears (e.g., after HMR)
+    // Self-heal if our session disappears (e.g., after HMR). Skip when concurrent user limit
+    // is showing so we don't spam recovery attempts when the connection was rejected.
     const missingSessionRecoveryTimerRef = useRef(null);
     const missingSessionRecoveryAttemptsRef = useRef(0);
+    const concurrentUserLimitErrorRef = useRef(null);
     useEffect(() => {
+        if (concurrentUserLimitErrorRef.current !== null)
+            return;
         const hasMySession = activeSessions.some((s) => s.sessionId === sessionId);
         if (hasMySession) {
             // Reset recovery state when we see ourselves again
@@ -857,7 +1099,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             return;
         const attempt = missingSessionRecoveryAttemptsRef.current + 1;
         const delay = Math.min(250 * Math.pow(2, attempt - 1), 2000);
-        console.warn(`⚠️ Current session not present in active sessions. Recovery attempt ${attempt} in ${delay}ms...`);
         missingSessionRecoveryTimerRef.current = setTimeout(() => {
             missingSessionRecoveryTimerRef.current = null;
             missingSessionRecoveryAttemptsRef.current = attempt;
@@ -866,6 +1107,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
             else {
                 // Force a reconnect to refresh presence after several failed nudges
+                console.warn("Session presence did not recover after retries. Forcing reconnect.");
                 try {
                     globalThis.editorSocket?.close(4000, "recover-presence");
                 }
@@ -885,22 +1127,56 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         // Initialize lastUrlRef to current URL on mount
         lastUrlRef.current = window.location.href;
         const keepAliveUrl = "/parhelia/keepalive";
-        const interval = setInterval(() => {
-            fetch(keepAliveUrl + "?ts=" + Date.now())
+        const runSessionCheck = () => {
+            fetch(keepAliveUrl + "?ts=" + Date.now(), {
+                credentials: "include",
+                headers: { "Cache-Control": "no-cache" },
+            })
                 .then((response) => {
-                if (response.status === 401 || response.status === 403) {
-                    toast.error("Your session has expired", {
-                        description: "Please login again to continue editing.",
-                        action: {
-                            label: "Login",
-                            onClick: () => (window.location.href = "/sitecore/login"),
+                if (response.headers.get("X-Parhelia-Session-Revoked") === "true") {
+                    window.dispatchEvent(new CustomEvent("parhelia:session-revoked", {
+                        detail: { reason: "session-revoked" },
+                    }));
+                    return;
+                }
+                // A redirected response (e.g. to /sitecore/login) or an explicit
+                // 401/403 both mean the user is no longer authenticated. Let a
+                // single event-driven toast handle the UI.
+                const finalUrl = response.url || "";
+                const redirectedToLogin = response.redirected &&
+                    (/\/sitecore\/login/i.test(finalUrl) ||
+                        /[?&]returnUrl=/i.test(finalUrl));
+                if (redirectedToLogin ||
+                    response.status === 401 ||
+                    response.status === 403) {
+                    window.dispatchEvent(new CustomEvent("parhelia:session-expired", {
+                        detail: {
+                            reason: redirectedToLogin
+                                ? "login-redirect"
+                                : `status-${response.status}`,
                         },
-                        duration: Infinity,
-                    });
+                    }));
                 }
             })
                 .catch((error) => console.error("Keep Alive error:", error));
-        }, 5 * 60 * 1000);
+        };
+        const keepaliveIntervalMs = (() => {
+            const param = new URLSearchParams(window.location.search).get("keepaliveIntervalMs");
+            if (!param)
+                return 5 * 60 * 1000;
+            const ms = parseInt(param, 10);
+            return Number.isFinite(ms) && ms >= 2000 && ms <= 60000
+                ? ms
+                : 5 * 60 * 1000;
+        })();
+        const interval = setInterval(() => {
+            runSessionCheck();
+        }, keepaliveIntervalMs);
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === "visible") {
+                runSessionCheck();
+            }
+        };
         const handleMessage = (event) => {
             if (event.data.type === "componentsSelected") {
                 setSelection(event.data.componentIds);
@@ -908,35 +1184,44 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         };
         // Listen for browser navigation events (back/forward buttons)
         const handlePopState = (event) => {
-            const newUrl = window.location.href;
+            const newUrl = `${window.location.pathname}${window.location.search}`;
             if (newUrl !== lastUrlRef.current) {
                 lastUrlRef.current = newUrl;
                 // Mark that we're handling a popstate to prevent URL sync from pushing to history
                 isHandlingPopStateRef.current = true;
                 // Sync URL parameters back to component state for browser navigation
                 const urlParams = new URLSearchParams(window.location.search);
-                // Handle workspace changes (with legacy view fallback)
-                const urlWorkspace = urlParams.get("workspace") ?? urlParams.get("view");
-                if (urlWorkspace && urlWorkspace !== viewNameRef.current) {
+                const urlWorkspace = urlParams.get("workspace");
+                if (urlWorkspace && urlWorkspace !== workspaceIdRef.current) {
                     setWorkspaceId(urlWorkspace);
                 }
-                // Handle sidebar changes
+                // Handle sidebar changes — clear when absent so state matches the URL
                 const sidebarParam = urlParams.get("sidebar");
-                if (sidebarParam !== null) {
-                    const newSidebars = sidebarParam.split(",").filter(Boolean);
-                    setOpenSidebars(newSidebars);
-                }
+                const newSidebars = sidebarParam
+                    ? sidebarParam.split(",").filter(Boolean)
+                    : [];
+                setOpenSidebars(newSidebars);
                 // Handle wizard ID changes
                 const wizardId = urlParams.get("wizardid");
                 setCurrentWizardId(wizardId);
-                // Handle compare mode changes
-                const compareValue = urlParams.get("compare") === "true";
-                if (compareValue !== compareMode) {
-                    setCompareMode(compareValue);
+                // Handle compare mode changes — always set to avoid stale-closure mismatch
+                // (React skips re-render when the value is unchanged)
+                setCompareMode(urlParams.get("compare") === "true");
+                // Handle help panel changes
+                const helpParam = urlParams.get("help");
+                if (helpParam) {
+                    setHelpTerminalActiveTab("manual");
+                    setShowHelpTerminal(true);
+                    setSelectedHelpSectionId(helpParam === "contents" || helpParam === "true"
+                        ? null
+                        : helpParam);
                 }
-                // Handle mode changes
+                else {
+                    handleSetShowHelpTerminal(false);
+                }
+                // Handle mode changes — always set to avoid stale-closure mismatch
                 const urlMode = urlParams.get("mode");
-                if (urlMode && urlMode !== mode) {
+                if (urlMode) {
                     setMode(urlMode);
                 }
                 // Handle fullscreen changes (shell-level state)
@@ -989,9 +1274,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         };
         window.addEventListener("message", handleMessage);
         window.addEventListener("popstate", handlePopState);
+        window.addEventListener("visibilitychange", handleVisibilityChange);
         return () => {
             window.removeEventListener("message", handleMessage);
             window.removeEventListener("popstate", handlePopState);
+            window.removeEventListener("visibilitychange", handleVisibilityChange);
             clearInterval(interval);
         };
     }, []);
@@ -1001,14 +1288,34 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         if (searchParams.get("noTour") !== null) {
             return;
         }
+        // Don't start tour when there are setup errors (user is or will be on system status page)
+        if (startupChecks.state === "complete" && startupChecks.hasBlockingIssues) {
+            return;
+        }
+        // Don't start tour when already on settings system status page
+        if (viewName === "settings" && searchParams.get("ccpanel") === "status") {
+            return;
+        }
+        // Wait for startup checks so we know whether we'll redirect to status
+        if (startupChecks.state !== "complete") {
+            return;
+        }
         const tour = configuration.activeTour;
         const key = tour === "default" ? "editor.tourShown" : "editor.tourShown." + tour;
-        const tourShown = localStorage.getItem(key);
+        const tourShown = localStorageService.getString(key);
         if (!tourShown) {
             startTour();
-            localStorage.setItem(key, "true");
+            localStorageService.setString(key, "true");
         }
-    }, [user]);
+    }, [
+        user,
+        startupChecks.state,
+        startupChecks.hasBlockingIssues,
+        viewName,
+        searchParams,
+        configuration.activeTour,
+        startTour,
+    ]);
     // WebSocket initialization is performed after messageHandler is defined
     // Defer URL sync until loadItem is defined below
     // Mark end of initial load phase
@@ -1140,7 +1447,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     const loadComments = useCallback(async () => {
         if (!currentItemDescriptor)
             return;
-        const result = await getComments(currentItemDescriptor.id, currentItemDescriptor.language, currentItemDescriptor.version);
+        const reviewId = searchParams.get("reviewId");
+        const result = await getComments(currentItemDescriptor.id, currentItemDescriptor.language, currentItemDescriptor.version, reviewId ?? undefined);
         if (handleErrorResult(result, ui, state))
             return;
         setComments((x) => {
@@ -1153,7 +1461,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             allComments.sort((a, b) => a.position - b.position);
             return allComments;
         });
-    }, [currentItemDescriptor]);
+    }, [currentItemDescriptor, searchParams]);
     // Assuming currentItemDescriptor, ui, state, handleErrorResult, and setSuggestedEdits
     // are available in your component context.
     const loadSuggestedEdits = useCallback(async () => {
@@ -1162,7 +1470,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         const result = await getSuggestedEdits(item.descriptor.id, item.descriptor.language, item.descriptor.version);
         if (handleErrorResult(result, ui, state))
             return;
-        setSuggestedEdits(result.data || []);
+        const edits = result.data || [];
+        setSuggestedEdits(edits);
     }, [item]);
     const loadFavorites = useCallback(async () => {
         try {
@@ -1236,6 +1545,25 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             return idB.localeCompare(idA);
         });
     }, []);
+    const normalizeEditHistoryPayload = useCallback((value) => {
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (value && typeof value === "object") {
+            const payload = value;
+            const candidates = [
+                payload.operations,
+                payload.history,
+                payload.items,
+                payload.data,
+            ];
+            const firstArray = candidates.find((candidate) => Array.isArray(candidate));
+            if (Array.isArray(firstArray)) {
+                return firstArray;
+            }
+        }
+        return [];
+    }, []);
     useEffect(() => {
         // Read fresh page from the mutable slot context ref chain.
         // The slot context uses a stable ref that is mutated in-place (see editorSlotContext.ts),
@@ -1258,7 +1586,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         if (handleErrorResult(result, ui, state))
             return;
         setEditHistory((prev) => {
-            const next = result.data || [];
+            const next = normalizeEditHistoryPayload(result.data);
             if (!prev.length)
                 return sortEditHistoryByDateDesc(next);
             if (!next.length)
@@ -1317,6 +1645,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         const shouldFilterByLanguage = filterByLanguage !== undefined
             ? filterByLanguage
             : filterByCurrentLanguage;
+        const trimmedHistoryQuery = historySearchQuery.trim();
+        const historyQuery = trimmedHistoryQuery.length > 0 ? trimmedHistoryQuery : undefined;
         if (currentMode === "global") {
             // Global mode: optionally filter by session and/or language
             const currentLanguage = item?.descriptor?.language || currentItemDescriptor?.language;
@@ -1326,13 +1656,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                 language: shouldFilterByLanguage && currentLanguage
                     ? currentLanguage
                     : undefined,
+                query: historyQuery,
             });
             if (handleErrorResult(result, ui, state)) {
                 console.error("[EditorShell] Failed to load history:", result);
                 return;
             }
             setEditHistory((prev) => {
-                const next = result.data || [];
+                const next = normalizeEditHistoryPayload(result.data);
                 const scope = {
                     mode: currentMode,
                     filterBySession: shouldFilterBySession,
@@ -1343,8 +1674,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                 };
                 if (!prev.length)
                     return sortEditHistoryByDateDesc(next.filter((op) => matchesHistoryScope(op, scope)));
-                if (!next.length)
+                if (!next.length) {
+                    // When searching, respect the empty result — don't fall back to previous items
+                    if (historyQuery)
+                        return [];
                     return sortEditHistoryByDateDesc(prev.filter((op) => matchesHistoryScope(op, scope)));
+                }
                 const prevById = new Map(prev.map((x) => [x.id, x]));
                 const nextById = new Set(next.map((x) => x.id));
                 const merged = next
@@ -1380,9 +1715,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                     return mergedOp;
                 });
                 // Preserve operations that arrived via WebSocket during the fetch window
-                for (const [id, priorOp] of prevById) {
-                    if (!nextById.has(id) && matchesHistoryScope(priorOp, scope)) {
-                        merged.push(priorOp);
+                // but not when filtering by search query — search results are authoritative
+                if (!historyQuery) {
+                    for (const [id, priorOp] of prevById) {
+                        if (!nextById.has(id) && matchesHistoryScope(priorOp, scope)) {
+                            merged.push(priorOp);
+                        }
                     }
                 }
                 return sortEditHistoryByDateDesc(merged);
@@ -1405,12 +1743,13 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             const result = await getEditHistory({
                 item: itemFilter,
                 sessionId: shouldFilterBySession ? sessionId : undefined,
+                query: historyQuery,
             });
             if (handleErrorResult(result, ui, state)) {
                 console.error("[EditorShell] Failed to load item history:", result);
                 return;
             }
-            let operations = result.data || [];
+            let operations = normalizeEditHistoryPayload(result.data);
             // Client-side version filtering for current-version mode
             if (currentMode === "current-version") {
                 // Defensive filter: only include operations for the current version
@@ -1433,8 +1772,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                 };
                 if (!prev.length)
                     return sortEditHistoryByDateDesc(operations.filter((op) => matchesHistoryScope(op, scope)));
-                if (!operations.length)
+                if (!operations.length) {
+                    if (historyQuery)
+                        return [];
                     return sortEditHistoryByDateDesc(prev.filter((op) => matchesHistoryScope(op, scope)));
+                }
                 const prevById = new Map(prev.map((x) => [x.id, x]));
                 const nextById = new Set(operations.map((x) => x.id));
                 const merged = operations
@@ -1470,9 +1812,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                     return mergedOp;
                 });
                 // Preserve operations that arrived via WebSocket during the fetch window
-                for (const [id, priorOp] of prevById) {
-                    if (!nextById.has(id) && matchesHistoryScope(priorOp, scope)) {
-                        merged.push(priorOp);
+                // but not when filtering by search query — search results are authoritative
+                if (!historyQuery) {
+                    for (const [id, priorOp] of prevById) {
+                        if (!nextById.has(id) && matchesHistoryScope(priorOp, scope)) {
+                            merged.push(priorOp);
+                        }
                     }
                 }
                 return sortEditHistoryByDateDesc(merged);
@@ -1483,9 +1828,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         historyMode,
         showOnlyMyChanges,
         filterByCurrentLanguage,
+        historySearchQuery,
         item,
         currentItemDescriptor,
         matchesHistoryScope,
+        normalizeEditHistoryPayload,
         sortEditHistoryByDateDesc,
     ]);
     // Debounced history refresh to avoid hammering `/parhelia/editHistory` on rapid UI changes.
@@ -1551,13 +1898,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
         }
         else if (historyMode !== "global" && currentItemDescriptor) {
+            // Always load immediately for page-centric/current-version/timeline so we don't show
+            // an empty history list for the debounce window (e.g. 600ms). The effect only runs on
+            // mode or item id/lang/version change, not on every keystroke, so this avoids flaky
+            // undo/redo tests and improves UX when switching to page-centric.
             if (!historyInitialLoadDoneRef.current) {
                 historyInitialLoadDoneRef.current = true;
-                refreshHistoryRef.current(historyMode);
-            }
-            else {
-                debouncedRefreshHistoryRef.current(historyMode);
             }
+            refreshHistoryRef.current(historyMode);
         }
         else if (historyMode !== "global" && !currentItemDescriptor) {
             // Clear history if no item loaded in page-centric modes
@@ -1570,6 +1918,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         historyMode,
         showOnlyMyChanges,
         filterByCurrentLanguage,
+        historySearchQuery,
         currentItemDescriptor?.id,
         currentItemDescriptor?.language,
         currentItemDescriptor?.version,
@@ -1634,6 +1983,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         if (isInitialLoad)
             return;
         const current = new URLSearchParams(window.location.search);
+        const urlWorkspace = current.get("workspace");
+        const urlView = current.get("view");
+        const isWorkspaceTransitioning = !!urlWorkspace && urlWorkspace !== viewName;
         // Sync item-related parameters only when an item is selected
         if (currentItemDescriptor) {
             if (current.get("itemid") !== currentItemDescriptor.id) {
@@ -1664,20 +2016,21 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             // If reviewId or urlItemId exists, preserve itemid/lang/version from URL
         }
         // Always sync workspace-related parameters regardless of item selection
-        if (current.get("workspace") !== viewName) {
+        if (!isWorkspaceTransitioning && current.get("workspace") !== viewName) {
             current.set("workspace", viewName);
         }
-        current.delete("view"); // Remove legacy view param
-        // Sync sidebar state
+        // Sync sidebar state. Always write a value (sentinel when empty) so that an
+        // explicit "user closed everything" state survives a reload.
         const currentSidebars = current.get("sidebar") ?? "";
-        const newSidebars = openSidebars.join(",");
+        const newSidebars = sidebarUrlValue(openSidebars);
         if (currentSidebars !== newSidebars) {
-            if (newSidebars) {
-                current.set("sidebar", newSidebars);
-            }
-            else {
-                current.delete("sidebar");
-            }
+            current.set("sidebar", newSidebars);
+        }
+        if (showHelpTerminal) {
+            current.set("help", selectedHelpSectionId ?? "contents");
+        }
+        else {
+            current.delete("help");
         }
         if (!compareMode) {
             current.delete("compare");
@@ -1703,15 +2056,15 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         else {
             current.delete("wizardid");
         }
-        // Only preserve ccpanel parameter when on settings view, remove it otherwise
-        if (viewName === "settings") {
-            const ccpanel = current.get("ccpanel");
-            if (ccpanel) {
-                current.set("ccpanel", ccpanel);
-            }
-        }
-        else {
+        // Preserve settings-specific parameters while transitioning into Settings too.
+        // Some callers update the URL first and switch the workspace state a moment later.
+        const isSettingsNavigation = viewName === "settings" ||
+            urlWorkspace === "settings" ||
+            urlView === "settings";
+        if (!isSettingsNavigation) {
             current.delete("ccpanel");
+            current.delete("providerId");
+            current.delete("modelId");
         }
         // Preserve reviewId parameter if it exists (for review links)
         // This ensures review links don't lose the reviewId when URL is synced
@@ -1724,17 +2077,42 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         const browserPathname = typeof window !== "undefined" ? window.location.pathname : pathname;
         const newUrl = `${browserPathname}?${current.toString()}`;
         const oldUrl = `${browserPathname}${window.location.search}`;
+        const isRestoringLastSyncedUrl = newUrl === lastUrlRef.current;
         // Skip pushing to history if we're handling a popstate event (browser back/forward)
         // This prevents the URL sync from overwriting the history during back navigation
         if (isHandlingPopStateRef.current) {
             return;
         }
         if (newUrl !== oldUrl) {
-            window.history.pushState(null, "", newUrl);
-            // Update lastUrlRef so the popstate handler knows the current URL
-            // This fixes the issue where goBack() wouldn't work because lastUrl was stale
+            if (isFirstUrlSyncRef.current ||
+                switchWorkspacePushedRef.current ||
+                isRestoringLastSyncedUrl) {
+                window.history.replaceState(getCurrentHistoryState(), "", newUrl);
+                isFirstUrlSyncRef.current = false;
+                switchWorkspacePushedRef.current = false;
+            }
+            else {
+                window.history.pushState(getCurrentHistoryState(), "", newUrl);
+            }
             lastUrlRef.current = newUrl;
         }
+        else {
+            // Even when the first sync is a no-op (URL already matches state), consume
+            // the first-sync flag. Otherwise the *next* real change (e.g. user selecting
+            // a different item) would hit the replaceState branch and overwrite the
+            // landing history entry — eating the "back" target and making browser back
+            // skip past the initial page.
+            if (isFirstUrlSyncRef.current) {
+                isFirstUrlSyncRef.current = false;
+                lastUrlRef.current = newUrl;
+            }
+            if (switchWorkspacePushedRef.current) {
+                // A workspace change may already have pushed the exact target URL. If we leave
+                // this flag set, the next unrelated item navigation will incorrectly replace
+                // history instead of pushing a new entry, which breaks browser back/forward.
+                switchWorkspacePushedRef.current = false;
+            }
+        }
     }, [
         currentItemDescriptor,
         viewName,
@@ -1746,6 +2124,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         fullscreen,
         currentWizardId,
         openSidebars,
+        showHelpTerminal,
+        selectedHelpSectionId,
     ]);
     useEffect(() => {
         async function load() {
@@ -1842,12 +2222,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                     "en",
                 version: 0,
             };
-        const loadedItem = await itemsRepository.getItem(itemToLoad);
-        if (!loadedItem) {
-            return undefined;
-        }
         // ensure this is object has no additional properties
         itemToLoad = getItemDescriptor(itemToLoad);
+        const requestedItemKey = makeItemKey(itemToLoad);
         // Check if item is already open in any slot - if so, reuse that slot instead of creating a new one
         const existingSlotForItem = editorSlots.find((s) => s.itemDescriptor.id === itemToLoad.id &&
             s.itemDescriptor.language === itemToLoad.language &&
@@ -1858,6 +2235,17 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             !options?.openInNewSlot &&
             !options?.targetSlotId) {
             const isExistingSlotActive = existingSlotForItem.slotId === activeSlotIdRef.current;
+            if (isExistingSlotActive) {
+                latestGlobalLoadKeyRef.current = requestedItemKey;
+            }
+            const loadedItem = await itemsRepository.getItem(itemToLoad);
+            if (!loadedItem) {
+                return undefined;
+            }
+            if (isExistingSlotActive &&
+                latestGlobalLoadKeyRef.current !== requestedItemKey) {
+                return loadedItem;
+            }
             // If forceRefresh is true, update the slot with a new refreshToken to trigger a reload
             if (options?.forceRefresh) {
                 setEditorSlots((prev) => {
@@ -1928,12 +2316,30 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             return next;
         });
         // Decide whether this load should update the global "current item" state.
-        // - If we're loading into an inactive slot (e.g. openInNewSlot), do NOT update URL/tree/controls.
-        // - If the slot is active (or is becoming active as the first slot), do update.
+        // - If we're loading into an inactive slot we won't normally touch, do NOT update URL/tree/controls.
+        // - If the slot is active, becoming active as the first slot, or is a brand-new
+        //   slot the caller explicitly opened, do update.
         const isFirstSlot = editorSlots.length === 0;
-        const shouldUpdateGlobalCurrentItem = isFirstSlot || targetSlotId === activeSlotIdRef.current;
-        // Active slot is controlled ONLY by mouse hover - only activate the first slot on initial load
-        if (isFirstSlot) {
+        const isExplicitNewSlot = options?.openInNewSlot === true && !options?.targetSlotId;
+        const shouldUpdateGlobalCurrentItem = isFirstSlot ||
+            isExplicitNewSlot ||
+            targetSlotId === activeSlotIdRef.current;
+        if (shouldUpdateGlobalCurrentItem) {
+            latestGlobalLoadKeyRef.current = requestedItemKey;
+        }
+        const loadedItem = await itemsRepository.getItem(itemToLoad);
+        if (!loadedItem) {
+            return undefined;
+        }
+        if (shouldUpdateGlobalCurrentItem &&
+            latestGlobalLoadKeyRef.current !== requestedItemKey) {
+            return loadedItem;
+        }
+        // Activate the new slot when this is either the initial first slot, or the
+        // caller explicitly opened the item in a new slot — focus follows the action so
+        // the user immediately sees what they just opened. Beyond that, slot focus is
+        // driven by mouse hover/click.
+        if (isFirstSlot || isExplicitNewSlot) {
             activeSlotIdRef.current = targetSlotId;
             setActiveSlotId(targetSlotId);
         }
@@ -2039,9 +2445,10 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     useEffect(() => {
         if (fullscreen &&
             !searchParams.get("fullscreen") &&
-            !configuration.forceFullscreen)
+            !configuration.forceFullscreen &&
+            !isMobile)
             setShowFullscreenHint(true);
-    }, [fullscreen, configuration.forceFullscreen, searchParams]);
+    }, [fullscreen, configuration.forceFullscreen, searchParams, isMobile]);
     const state = {
         page,
         configuration,
@@ -2140,20 +2547,35 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                     ? existingOp.progress
                     : op.progress;
                 // IMPORTANT: Once canUndo becomes true, never downgrade it to false,
-                // UNLESS this update indicates the operation was undone. When an undo
-                // completes, the server sends canUndo: false and canRedo: true (or undone: true).
-                // We must respect that transition so the UI reflects the undo.
-                const isUndoUpdate = op.undone === true || op.canRedo === true;
+                // UNLESS this update indicates the operation was undone.
+                // Runtime logs show long-running undo completion can arrive as:
+                // - existing: canUndo=true, executionStatus=executing
+                // - incoming: canUndo=false, executionStatus=completed
+                // without explicit undone/canRedo flags yet.
+                const isExplicitUndoUpdate = op.undone === true || op.canRedo === true;
+                const isInferredUndoCompletion = existingOp.executionStatus === "executing" &&
+                    op.executionStatus === "completed" &&
+                    existingOp.canUndo === true &&
+                    op.canUndo === false;
+                const isUndoUpdate = isExplicitUndoUpdate || isInferredUndoCompletion;
                 const mergedCanUndo = isUndoUpdate
                     ? false
                     : existingOp.canUndo === true
                         ? true
                         : op.canUndo;
+                const mergedCanRedo = isUndoUpdate
+                    ? true
+                    : op.canRedo ?? existingOp.canRedo;
+                const mergedUndone = isUndoUpdate
+                    ? true
+                    : op.undone ?? existingOp.undone;
                 const mergedOp = {
                     ...existingOp,
                     ...op,
                     progress: mergedProgress,
                     canUndo: mergedCanUndo,
+                    canRedo: mergedCanRedo,
+                    undone: mergedUndone,
                 };
                 // Ensure undone operations always have canRedo: true.
                 if (mergedOp.undone && !mergedOp.canRedo) {
@@ -2207,10 +2629,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     });
     // Ref for markOperationComplete callback (needed because operationsContext is created later)
     const markOperationCompleteRef = useRef(null);
-    // When the websocket is reconnecting, we can briefly lose the ability to send messages.
-    // Agent dialog responses (e.g. questionnaire cancel/submit) must not be dropped, otherwise
-    // the backend tool call can remain pending and tests/users will hang.
-    const pendingAgentDialogResponsesRef = useRef([]);
     // WebSocket message handler and connection
     const messageHandler = useSocketMessageHandler({
         sessionId,
@@ -2236,28 +2654,31 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             markOperationCompleteRef.current?.(operationId);
         },
     });
+    // Concurrent user limit error state
+    const [concurrentUserLimitError, setConcurrentUserLimitError] = useState(null);
+    concurrentUserLimitErrorRef.current = concurrentUserLimitError;
+    const handleRetryConnection = useCallback(() => {
+        setConcurrentUserLimitError(null);
+        // Force reconnection by triggering a new connection attempt
+        // The useEditorWebSocket hook will check availability again
+        const socket = globalThis.editorSocket;
+        if (socket) {
+            socket.close();
+            delete globalThis.editorSocket;
+        }
+        // The hook will automatically attempt to reconnect
+    }, []);
     const { socketRef: socketInstanceRef } = useEditorWebSocket({
         sessionId,
         onMessage: messageHandler,
         onOpen: async () => {
+            // Clear concurrent user limit error on successful connection
+            setConcurrentUserLimitError(null);
+            // Startup WebSocket probe may have failed with a blocking error while seats were full;
+            // re-run status checks quietly so "1 error" does not stick after a successful connect.
+            void startupChecks.recheckQuiet();
             // Increment socket connection version to trigger re-subscriptions
             setSocketConnectionVersion((v) => v + 1);
-            // Flush any queued agent dialog responses now that the socket is open.
-            // Keep this early so pending tool calls unblock ASAP.
-            try {
-                if (socketInstanceRef.current &&
-                    socketInstanceRef.current.readyState === WebSocket.OPEN &&
-                    pendingAgentDialogResponsesRef.current.length > 0) {
-                    // FIFO flush
-                    while (pendingAgentDialogResponsesRef.current.length > 0) {
-                        const queued = pendingAgentDialogResponsesRef.current.shift();
-                        socketInstanceRef.current.send(JSON.stringify(queued));
-                    }
-                }
-            }
-            catch (e) {
-                console.error("Failed to flush queued agent dialog responses:", e);
-            }
             // Fetch any running operations on (re)connect for auto-resume
             // This ensures the UI shows operations that are still executing
             try {
@@ -2273,24 +2694,62 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
         },
         onError: (error) => console.error("WebSocket error:", error),
+        onConcurrentUserLimit: (error) => {
+            setConcurrentUserLimitError(error);
+        },
+        onSessionRevoked: () => promptSessionReconnect("session-revoked"),
         connectSocket,
         requestQuota,
         sendClientInfo,
+        setSocketDiagnostics,
     });
+    useEffect(() => {
+        const hasMySession = activeSessions.some((s) => s.sessionId === sessionId);
+        if (hasMySession &&
+            socketInstanceRef.current?.readyState === WebSocket.OPEN) {
+            toast.dismiss("session-revoked");
+        }
+    }, [activeSessions, sessionId, socketConnectionVersion, socketInstanceRef]);
+    useEffect(() => {
+        const handleRevoked = (event) => {
+            const customEvent = event;
+            promptSessionReconnect(customEvent?.detail?.reason);
+        };
+        window.addEventListener("parhelia:session-revoked", handleRevoked);
+        return () => {
+            window.removeEventListener("parhelia:session-revoked", handleRevoked);
+        };
+    }, [promptSessionReconnect]);
+    // Show a single "session expired" toast with a Login action when any
+    // service call (or the keepalive check) detects that the user is no
+    // longer authenticated. Using a stable toast id coalesces the toast so a
+    // burst of failing calls does not spam the UI with duplicate toasts.
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const handleExpired = () => {
+            toast.error("Your session has expired", {
+                id: "session-expired",
+                description: "Please login again to continue editing.",
+                action: {
+                    label: "Login",
+                    onClick: () => {
+                        window.location.href = "/sitecore/login";
+                    },
+                },
+                duration: Infinity,
+            });
+        };
+        window.addEventListener("parhelia:session-expired", handleExpired);
+        return () => {
+            window.removeEventListener("parhelia:session-expired", handleExpired);
+        };
+    }, []);
     const sendSocketMessage = useCallback((message) => {
         if (socketInstanceRef.current &&
             socketInstanceRef.current.readyState === WebSocket.OPEN) {
             socketInstanceRef.current.send(JSON.stringify(message));
         }
-        else if (message.type === "agent-dialog-response") {
-            // Queue dialog responses to avoid losing them during reconnects.
-            pendingAgentDialogResponsesRef.current.push(message);
-            // Prevent unbounded growth in pathological scenarios.
-            if (pendingAgentDialogResponsesRef.current.length > 50) {
-                pendingAgentDialogResponsesRef.current =
-                    pendingAgentDialogResponsesRef.current.slice(-50);
-            }
-        }
     }, [socketInstanceRef]);
     // URL update helper - defined early so it can be used by workspace/sidebar functions
     const updateUrl = useCallback((params) => {
@@ -2309,7 +2768,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             ? `${browserPathname}?${queryString}`
             : browserPathname;
         if (typeof window !== "undefined") {
-            window.history.pushState(null, "", newUrl);
+            window.history.pushState(getCurrentHistoryState(), "", newUrl);
+            lastUrlRef.current = newUrl;
         }
         else {
             router.push(newUrl, { scroll: false });
@@ -2334,8 +2794,13 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             if (!options?.skipNavigationHistory) {
                 addNavigationEntry(targetWorkspaceId, item);
             }
-            // Update URL
-            updateUrl({ workspace: targetWorkspaceId });
+            // Mark that we're pushing from switchWorkspace so the URL sync effect
+            // will replaceState instead of pushing a second history entry.
+            switchWorkspacePushedRef.current = true;
+            updateUrl({
+                workspace: targetWorkspaceId,
+                ...options?.urlParams,
+            });
             if (typeof document.startViewTransition === "function") {
                 document.startViewTransition(() => {
                     flushSync(() => {
@@ -2355,14 +2820,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         updateUrl,
         handleSetShowAgentsPanel,
     ]);
-    // Legacy alias for backwards compatibility
-    const switchView = useCallback((viewName, options) => {
-        // Handle ccpanel for settings workspace
-        if (options?.ccpanel) {
-            updateUrl({ ccpanel: options.ccpanel, workspace: viewName });
-        }
-        switchWorkspace(viewName, options);
-    }, [switchWorkspace, updateUrl]);
     // Helper: get all sidebar IDs that should be preserved (locked sidebars + their stack mates)
     const getPreservedSidebarIds = useCallback(() => {
         const lockedSet = new Set(lockedSidebarsRef.current);
@@ -2400,8 +2857,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             setOpenSidebars(newSidebars);
             setLockedSidebars((locked) => locked.filter((id) => id !== sidebarId));
             setSidebarStacks((prevStacks) => normalizeSidebarStacks(newSidebars, prevStacks));
+            if (sidebarId === "agents-panel") {
+                setUserPreferences({ showAgentsPanel: false });
+            }
             startTransition(() => {
-                updateUrl({ sidebar: newSidebars.join(",") || undefined });
+                updateUrl({ sidebar: sidebarUrlValue(newSidebars) });
             });
             return;
         }
@@ -2414,34 +2874,69 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         ];
         openSidebarsRef.current = newSidebars;
         setOpenSidebars(newSidebars);
+        ensureSidebarPinned(sidebarId);
         setSidebarStacks((prevStacks) => normalizeSidebarStacks(newSidebars, prevStacks));
+        if (sidebarId === "agents-panel") {
+            setUserPreferences({ showAgentsPanel: true });
+        }
+        // On mobile, close the editor form panel when opening a sidebar
+        if (isMobile) {
+            setMobileEditorPanelOpenRaw(false);
+        }
         startTransition(() => {
-            updateUrl({ sidebar: newSidebars.join(",") || undefined });
+            updateUrl({ sidebar: sidebarUrlValue(newSidebars) });
         });
-    }, [updateUrl, getPreservedSidebarIds, normalizeSidebarStacks]);
+    }, [
+        updateUrl,
+        getPreservedSidebarIds,
+        normalizeSidebarStacks,
+        ensureSidebarPinned,
+        setUserPreferences,
+        isMobile,
+    ]);
     // Ensure a sidebar is open (without toggling it closed if already open)
-    const openSidebar = useCallback((sidebarId) => {
+    const openSidebar = useCallback((sidebarId, options) => {
         const currentOpenSidebars = openSidebarsRef.current;
         if (currentOpenSidebars.includes(sidebarId)) {
             // Already open, nothing to do
             return;
         }
-        // Keep sidebars that are locked OR in a stack with a locked sidebar
-        const preservedSet = getPreservedSidebarIds();
-        const newSidebars = [
-            ...currentOpenSidebars.filter((id) => preservedSet.has(id)), // Keep locked stacks
-            sidebarId, // Add the new one
-        ];
+        const preservedSet = options?.preserveOpenSidebars
+            ? undefined
+            : getPreservedSidebarIds();
+        const newSidebars = options?.preserveOpenSidebars
+            ? [...currentOpenSidebars, sidebarId]
+            : [
+                ...currentOpenSidebars.filter((id) => preservedSet?.has(id)),
+                sidebarId,
+            ];
         openSidebarsRef.current = newSidebars;
         setOpenSidebars(newSidebars);
+        ensureSidebarPinned(sidebarId);
         setSidebarStacks((prevStacks) => normalizeSidebarStacks(newSidebars, prevStacks));
+        if (sidebarId === "agents-panel") {
+            setUserPreferences({ showAgentsPanel: true });
+        }
+        // On mobile, close the editor form panel when opening a sidebar
+        if (isMobile) {
+            setMobileEditorPanelOpenRaw(false);
+        }
         startTransition(() => {
-            updateUrl({ sidebar: newSidebars.join(",") || undefined });
+            updateUrl({ sidebar: sidebarUrlValue(newSidebars) });
         });
-    }, [updateUrl, getPreservedSidebarIds, normalizeSidebarStacks]);
+    }, [
+        updateUrl,
+        getPreservedSidebarIds,
+        normalizeSidebarStacks,
+        ensureSidebarPinned,
+        setUserPreferences,
+        isMobile,
+    ]);
     // Toggle lock state for a sidebar stack (keeps it visible when selecting another)
     // When toggling any sidebar, we toggle the entire stack it belongs to
     const toggleSidebarLock = useCallback((sidebarId) => {
+        if (isMobile)
+            return;
         const currentStacks = sidebarStacksRef.current;
         const stackContainingSidebar = currentStacks.find((stack) => stack.includes(sidebarId));
         const sidebarIdsToToggle = stackContainingSidebar || [sidebarId];
@@ -2459,7 +2954,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                 ];
             }
         });
-    }, []);
+    }, [isMobile]);
     const stackSidebar = useCallback((sidebarId, targetSidebarId, position = "after") => {
         if (!sidebarId || !targetSidebarId || sidebarId === targetSidebarId)
             return;
@@ -2491,6 +2986,38 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             return normalizeSidebarStacks(openIds, next);
         });
     }, [normalizeSidebarStacks]);
+    const moveSidebarToColumn = useCallback((sidebarId, targetSidebarId, position = "after") => {
+        if (!sidebarId || !targetSidebarId || sidebarId === targetSidebarId) {
+            return;
+        }
+        const currentOpen = openSidebarsRef.current;
+        const baseOpen = currentOpen.filter((id) => id !== sidebarId);
+        const targetIndex = baseOpen.indexOf(targetSidebarId);
+        if (targetIndex === -1) {
+            return;
+        }
+        const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
+        const nextOpen = [...baseOpen];
+        nextOpen.splice(insertIndex, 0, sidebarId);
+        openSidebarsRef.current = nextOpen;
+        setOpenSidebars(nextOpen);
+        startTransition(() => {
+            updateUrl({ sidebar: sidebarUrlValue(nextOpen) });
+        });
+        setSidebarStacks((prev) => {
+            const normalized = normalizeSidebarStacks(nextOpen, prev);
+            const next = normalized
+                .map((stack) => stack.filter((id) => id !== sidebarId))
+                .filter((stack) => stack.length > 0);
+            const targetStackIndex = next.findIndex((stack) => stack.includes(targetSidebarId));
+            if (targetStackIndex === -1) {
+                next.push([sidebarId]);
+                return normalizeSidebarStacks(nextOpen, next);
+            }
+            next.splice(position === "before" ? targetStackIndex : targetStackIndex + 1, 0, [sidebarId]);
+            return normalizeSidebarStacks(nextOpen, next);
+        });
+    }, [normalizeSidebarStacks, updateUrl]);
     const unstackSidebar = useCallback((sidebarId) => {
         setSidebarStacks((prev) => {
             const openIds = openSidebarsRef.current;
@@ -2536,8 +3063,34 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     // Get resolved sidebar (with panels materialized)
     // Note: This is defined as a function that will be called later when editContext is available
     const sidebars = configuration.editor.sidebars ?? [];
+    const taskboardSidebarIds = new Set([
+        "taskboard-project-list",
+        "taskboard-my-tasks",
+    ]);
+    const getSidebarsForWorkspace = useCallback((targetWorkspaceId) => {
+        const isTaskboardWorkspace = targetWorkspaceId === "taskboard";
+        const workspaceAllowedSidebarIds = userInfo.workspaces?.find((w) => w.id === targetWorkspaceId)
+            ?.sidebars ?? [];
+        return sidebars.filter((s) => {
+            const isTaskboardSidebar = taskboardSidebarIds.has(s.id);
+            if (isTaskboardWorkspace && !isTaskboardSidebar)
+                return false;
+            if (!isTaskboardWorkspace && isTaskboardSidebar)
+                return false;
+            // Always show agents-panel regardless of workspace settings.
+            if (s.id === "agents-panel") {
+                return true;
+            }
+            // If no workspace settings or no sidebars defined for current workspace, show all.
+            if (workspaceAllowedSidebarIds.length === 0) {
+                return true;
+            }
+            // Only show sidebars that are in the allowed list for the current workspace.
+            return workspaceAllowedSidebarIds.includes(s.id);
+        });
+    }, [sidebars, userInfo.workspaces]);
     const getResolvedSidebar = useCallback((sidebarId) => {
-        const sidebar = sidebars.find((s) => s.id === sidebarId);
+        const sidebar = getSidebarsForWorkspace(workspaceId).find((s) => s.id === sidebarId);
         if (!sidebar)
             return undefined;
         // Resolve panel factories using editContextRef to avoid circular dependency
@@ -2551,7 +3104,44 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             ...sidebar,
             panels: resolvedPanels,
         };
-    }, [sidebars]);
+    }, [getSidebarsForWorkspace, workspaceId]);
+    // Track the last workspaceId this effect saw so we only auto-apply
+    // `currentWorkspace.defaultSidebars` on an actual workspace change. On initial mount
+    // the user's explicit empty state (sidebar=none in URL) must not be overwritten.
+    const prevWorkspaceIdForDefaultsRef = useRef(null);
+    useEffect(() => {
+        if (!currentWorkspace.supportsSidebars) {
+            return;
+        }
+        const prev = prevWorkspaceIdForDefaultsRef.current;
+        prevWorkspaceIdForDefaultsRef.current = workspaceId;
+        const isWorkspaceChange = prev !== null && prev !== workspaceId;
+        const allowedIds = new Set(getSidebarsForWorkspace(workspaceId).map((sidebar) => sidebar.id));
+        const currentOpen = openSidebarsRef.current;
+        let nextOpen = currentOpen.filter((id) => allowedIds.has(id));
+        if (isWorkspaceChange &&
+            nextOpen.length === 0 &&
+            currentWorkspace.defaultSidebars?.length) {
+            nextOpen = currentWorkspace.defaultSidebars.filter((id) => allowedIds.has(id));
+        }
+        const unchanged = nextOpen.length === currentOpen.length &&
+            nextOpen.every((id, index) => id === currentOpen[index]);
+        if (unchanged) {
+            return;
+        }
+        openSidebarsRef.current = nextOpen;
+        setOpenSidebars(nextOpen);
+        setSidebarStacks((prev) => normalizeSidebarStacks(nextOpen, prev));
+        startTransition(() => {
+            updateUrl({ sidebar: sidebarUrlValue(nextOpen) });
+        });
+    }, [
+        currentWorkspace,
+        getSidebarsForWorkspace,
+        normalizeSidebarStacks,
+        updateUrl,
+        workspaceId,
+    ]);
     // Listen for switch-workspace and open-sidebar commands from agents via websocket
     useEffect(() => {
         const handleAgentMessage = (message) => {
@@ -2765,9 +3355,45 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         }
         return true;
     }, [operations, ignoreBlur, sessionId]);
+    const quickSwitcherEntries = useMemo(() => {
+        const entries = [];
+        const seen = new Set();
+        const pushEntry = (entry) => {
+            const key = entry.item
+                ? `${entry.workspaceId}:${entry.item.id}:${entry.item.language}:${entry.item.version}`
+                : `${entry.workspaceId}:no-item`;
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            entries.push(entry);
+        };
+        for (const entry of navigationHistory) {
+            pushEntry(entry);
+        }
+        for (const entry of browseHistory) {
+            if (!entry.id || !entry.language)
+                continue;
+            pushEntry({
+                workspaceId,
+                item: {
+                    id: entry.id,
+                    language: entry.language,
+                    version: entry.version ?? 0,
+                },
+                timestamp: entry.visitedAt
+                    ? new Date(entry.visitedAt).getTime()
+                    : Date.now(),
+                displayName: entry.name || workspaceId,
+                itemName: entry.name,
+                itemPath: entry.path,
+                itemIcon: entry.icon,
+            });
+        }
+        return entries.slice(0, 25);
+    }, [navigationHistory, browseHistory, workspaceId]);
     // Quick switcher handlers
     const showQuickSwitcher = useCallback((show) => {
-        if (show && navigationHistory.length > 1) {
+        if (show && quickSwitcherEntries.length > 1) {
             setQuickSwitcherVisible(true);
             // Start with index 1 (second entry - previous entry) for quick switching
             setQuickSwitcherSelectedIndex(1);
@@ -2775,11 +3401,11 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         else {
             setQuickSwitcherVisible(false);
         }
-    }, [navigationHistory]);
+    }, [quickSwitcherEntries]);
     const cycleQuickSwitcher = useCallback((direction) => {
         if (!quickSwitcherVisible)
             return;
-        const maxItems = Math.min(5, navigationHistory.length);
+        const maxItems = Math.min(5, quickSwitcherEntries.length);
         setQuickSwitcherSelectedIndex((current) => {
             let newIndex = current;
             // Determine grid layout (responsive columns)
@@ -2824,9 +3450,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
             return newIndex;
         });
-    }, [quickSwitcherVisible, navigationHistory]);
+    }, [quickSwitcherVisible, quickSwitcherEntries]);
     const handleQuickSwitcherSelect = useCallback((index) => {
-        const selectedEntry = navigationHistory[index];
+        const selectedEntry = quickSwitcherEntries[index];
         if (selectedEntry) {
             // Determine target workspace: entries with items should go to "editor" workspace
             // (fixes issue where browse history entries initialized with wrong workspaceId)
@@ -2878,23 +3504,46 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         }
         setQuickSwitcherVisible(false);
     }, [
-        navigationHistory,
+        quickSwitcherEntries,
         loadItem,
         switchWorkspace,
         workspaceId,
         item,
         setNavigationHistory,
     ]);
+    useEffect(() => {
+        if (typeof window === "undefined" ||
+            process.env.PARHELIA_DEV_MODE !== "true") {
+            return;
+        }
+        window.__parheliaQuickSwitcherTestApi = {
+            open: () => showQuickSwitcher(true),
+            cycle: (direction = "next") => cycleQuickSwitcher(direction),
+            closeWithoutSelection: () => setQuickSwitcherVisible(false),
+            selectCurrent: () => handleQuickSwitcherSelect(quickSwitcherSelectedIndex),
+            getState: () => ({
+                visible: quickSwitcherVisible,
+                selectedIndex: quickSwitcherSelectedIndex,
+                entryCount: quickSwitcherEntries.length,
+                entries: quickSwitcherEntries.map((entry) => ({
+                    workspaceId: entry.workspaceId,
+                    itemId: entry.item?.id,
+                    displayName: entry.displayName,
+                })),
+            }),
+        };
+        return () => {
+            delete window.__parheliaQuickSwitcherTestApi;
+        };
+    }, [
+        showQuickSwitcher,
+        cycleQuickSwitcher,
+        handleQuickSwitcherSelect,
+        quickSwitcherSelectedIndex,
+    ]);
     const { handleKeyDown } = useKeyboardNavigation({
         editContextRef,
-        operations,
-        pageViewContext: activePageViewContext,
-        configuration,
-        item,
-        browseHistory,
-        loadItem,
-        showInfoToast,
-        showErrorToast,
+        keyboardCommands: activeKeyboardCommands,
         executeCommand,
         showQuickSwitcher,
         cycleQuickSwitcher,
@@ -3014,10 +3663,19 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
             return null;
         };
+        let modifierWasPressedOnMouseDown = false;
+        const handleMouseDown = (event) => {
+            modifierWasPressedOnMouseDown = event.ctrlKey || event.metaKey;
+        };
         const handleCtrlClick = async (event) => {
-            // Only proceed if Ctrl (or Cmd on Mac) is pressed
+            // Only proceed if Ctrl/Cmd was already pressed when the mouse interaction started.
+            // This avoids accidental navigation when users press Ctrl after selecting text to copy.
+            if (!modifierWasPressedOnMouseDown)
+                return;
+            // Also require the modifier to still be held for the final click event.
             if (!event.ctrlKey && !event.metaKey)
                 return;
+            modifierWasPressedOnMouseDown = false;
             const target = event.target;
             const text = getTextFromElement(target);
             if (text && isGuid(text)) {
@@ -3032,8 +3690,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                             skipViewChange: true,
                         });
                         if (item) {
-                            // Switch to the editor view
-                            switchView("editor", {
+                            switchWorkspace("editor", {
                                 skipNavigationHistory: true,
                             });
                             showInfoToast({
@@ -3059,12 +3716,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             }
         };
         if (typeof document !== "undefined") {
+            document.addEventListener("mousedown", handleMouseDown, true);
             document.addEventListener("click", handleCtrlClick, true);
             return () => {
+                document.removeEventListener("mousedown", handleMouseDown, true);
                 document.removeEventListener("click", handleCtrlClick, true);
             };
         }
-    }, [loadItem, switchView, showInfoToast, showErrorToast]);
+    }, [loadItem, switchWorkspace, showInfoToast, showErrorToast]);
     useEffect(() => {
         const handleGlobalBlur = () => {
             operations.onFieldBlur?.();
@@ -3102,21 +3761,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         // Otherwise, only show workspaces that are in the settings
         return workspaceIdsFromSettings.includes(w.id) && !w.visible;
     });
-    // Get sidebars allowed for the current workspace from settings
-    const currentWorkspaceSettings = userInfo.workspaces?.find((w) => w.id === workspaceId);
-    const allowedSidebarIds = currentWorkspaceSettings?.sidebars ?? [];
-    // Legacy: Calculate visible views for backwards compatibility
-    const allViews = (configuration.editor.views ?? [])
-        .filter((x) => {
-        return !x.visible && !x.hidden;
-    })
-        .filter((x) => !userInfo.views ||
-        userInfo.views.map((view) => view.name).includes(x.name));
-    const pinnedViews = userInfo.preferences?.pinnedViews ||
-        configuration.editor.defaultPinnedViews ||
-        [];
-    // Legacy visibleViews for backwards compatibility
-    const visibleViews = allViews.filter((view) => view.name === viewName || pinnedViews.includes(view.name));
     // Handle initial mode setup from URL (only on initial load)
     useEffect(() => {
         if (!isInitialLoad)
@@ -3161,7 +3805,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             // This is especially important when called from the tour, where the current workspace
             // might be the editor and URL-only navigation would get "corrected" back.
             try {
-                switchView("home", {
+                switchWorkspace("home", {
                     skipConfirmation: true,
                     skipNavigationHistory: true,
                 });
@@ -3208,7 +3852,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
             const current = new URLSearchParams(searchParams.toString());
             current.delete("version");
             current.delete("itemid");
-            current.delete("view"); // Remove legacy param
             current.delete("workspace"); // Clear workspace
             current.set("create", "1");
             const newUrl = `${pathname}?${current.toString()}`;
@@ -3488,6 +4131,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setShowOnlyMyChanges,
         filterByCurrentLanguage,
         setFilterByCurrentLanguage,
+        historySearchQuery,
+        setHistorySearchQuery,
         refreshHistory,
         isRefreshing,
         activeSessions,
@@ -3525,19 +4170,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         workspaceId,
         previousWorkspaceId,
         switchWorkspace,
-        // Sidebar state - filter by workspace settings if available
-        availableSidebars: (configuration.editor.sidebars ?? []).filter((s) => {
-            // Always show agents-panel regardless of workspace settings
-            if (s.id === "agents-panel") {
-                return true;
-            }
-            // If no workspace settings or no sidebars defined for current workspace, show all
-            if (!allowedSidebarIds || allowedSidebarIds.length === 0) {
-                return true;
-            }
-            // Only show sidebars that are in the allowed list for the current workspace
-            return allowedSidebarIds.includes(s.id);
-        }),
+        // Sidebar state
+        availableSidebars: getSidebarsForWorkspace(workspaceId),
         openSidebars,
         pinnedSidebars,
         lockedSidebars,
@@ -3547,17 +4181,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         toggleSidebarPin,
         toggleSidebarLock,
         stackSidebar,
+        moveSidebarToColumn,
         unstackSidebar,
         reorderSidebarInStack,
         reorderPinnedSidebars,
         reorderOpenSidebars,
         getResolvedSidebar,
-        // Legacy compatibility (deprecated)
-        viewName,
-        previousViewName,
-        switchView,
-        view: currentView,
-        visibleViews,
         compareMode,
         setCompareMode,
         fullscreen,
@@ -3597,6 +4226,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         addSocketMessageListener,
         sendSocketMessage,
         socketConnectionVersion,
+        socketDiagnostics,
         currentItemDescriptor,
         editorSlots,
         activeSlotId,
@@ -3609,6 +4239,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setActiveSlot,
         revision,
         notifyPageModelReady,
+        pageModelReadyToken,
         selectedComment,
         setSelectedComment,
         comments,
@@ -3687,8 +4318,18 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         setEnableCompletions,
         showComponentNavigator,
         setShowComponentNavigator: handleSetShowComponentNavigator,
+        isComponentNavigatorOpenForSlot,
+        setComponentNavigatorOpenForSlot,
         showAgentsPanel,
         setShowAgentsPanel: handleSetShowAgentsPanel,
+        editorFormHidden,
+        setEditorFormHidden: handleSetEditorFormHidden,
+        editorFormHintSeen,
+        markEditorFormHintSeen,
+        editorFormHintVisible,
+        showEditorFormHint,
+        dismissEditorFormHint,
+        editorFormToggleButtonRef,
         showMinimap,
         setShowMinimap: handleSetShowMinimap,
         showHelpTerminal,
@@ -3698,8 +4339,12 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         helpTerminalProfileName,
         helpTerminalActiveTab,
         setHelpTerminalActiveTab,
+        selectedHelpSectionId,
+        setSelectedHelpSectionId,
         showAgentsWorkspaceEditor,
         setShowAgentsWorkspaceEditor: handleSetShowAgentsWorkspaceEditor,
+        selectedAgentsWorkspaceAgentId,
+        setSelectedAgentsWorkspaceAgentId,
         activeEditorTab,
         setActiveEditorTab,
         showLayoutComponents,
@@ -3708,6 +4353,8 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         isQuotaExceeded: isQuotaExceeded(),
         getQuotaWarningMessage,
         isMobile,
+        mobileEditorPanelOpen,
+        setMobileEditorPanelOpen: handleSetMobileEditorPanelOpen,
         openDialog,
         webSocketMessages,
         clearWebSocketMessages: () => setWebSocketMessages([]),
@@ -3746,7 +4393,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         configuration,
         updateUrl,
         workspaceId,
-        switchView,
         pathname,
         router,
         item,
@@ -3776,7 +4422,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         currentWorkspace,
         previousWorkspaceId,
         switchWorkspace,
-        allowedSidebarIds,
         openSidebars,
         pinnedSidebars,
         lockedSidebars,
@@ -3788,9 +4433,6 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         reorderOpenSidebars,
         getResolvedSidebar,
         viewName,
-        previousViewName,
-        currentView,
-        visibleViews,
         compareMode,
         // Important: in multi-slot mode the active PageViewContext can change
         // without the base `pageViewContext` identity changing (e.g. switching slots).
@@ -3815,6 +4457,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         currentItemDescriptor,
         revision,
         notifyPageModelReady,
+        pageModelReadyToken,
         selectedComment,
         comments,
         availableCommentTags,
@@ -3833,6 +4476,7 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         quickSwitcherSelectedIndex,
         handleQuickSwitcherSelect,
         webSocketMessages,
+        socketDiagnostics,
         factoriesRef,
         user,
         statusMessage,
@@ -3841,10 +4485,22 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         isQuotaExceeded,
         getQuotaWarningMessage,
         isMobile,
+        mobileEditorPanelOpen,
+        handleSetMobileEditorPanelOpen,
         showComponentNavigator,
+        isComponentNavigatorOpenForSlot,
+        setComponentNavigatorOpenForSlot,
         handleSetShowComponentNavigator,
         showAgentsPanel,
         handleSetShowAgentsPanel,
+        editorFormHidden,
+        handleSetEditorFormHidden,
+        editorFormHintSeen,
+        markEditorFormHintSeen,
+        editorFormHintVisible,
+        showEditorFormHint,
+        dismissEditorFormHint,
+        editorFormToggleButtonRef,
         showMinimap,
         handleSetShowMinimap,
         showHelpTerminal,
@@ -3853,7 +4509,9 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
         helpTerminalProfileName,
         helpTerminalActiveTab,
         setHelpTerminalActiveTab,
+        selectedHelpSectionId,
         showAgentsWorkspaceEditor,
+        selectedAgentsWorkspaceAgentId,
         activeEditorTab,
         showLayoutComponents,
         openDialog,
@@ -4098,18 +4756,40 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
     //   prevDependencies.current = currentDependencies;
     //   editContextRef.current = editContext;
     // }, [editContext]);
+    // Auto-open the mobile editor panel for new selection/intent changes, but
+    // keep a manual close sticky for the exact same context.
+    useEffect(() => {
+        if (!isMobile || workspaceId !== "editor")
+            return;
+        if (activeEditorTab) {
+            handleSetMobileEditorPanelOpen(true);
+            return;
+        }
+        if (!(selection.length > 0 || insertMode))
+            return;
+        if (dismissedMobilePanelToken === mobilePanelDismissToken)
+            return;
+        handleSetMobileEditorPanelOpen(true);
+    }, [
+        activeEditorTab,
+        dismissedMobilePanelToken,
+        handleSetMobileEditorPanelOpen,
+        insertMode,
+        isMobile,
+        mobilePanelDismissToken,
+        selection,
+        workspaceId,
+    ]);
     useEffect(() => {
         fieldsEditContext.clearModifiedFields();
     }, [currentItemDescriptor]);
-    if (!currentView)
+    if (!currentWorkspace)
         return null;
-    const editorUi = fullscreen ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "fixed inset-0 flex", children: [_jsx(PageViewerFrame, { compareView: compareMode, pageViewContext: activePageViewContext }), _jsx(FullscreenControls, { device: activePageViewContext.device, setDevice: (d) => activePageViewContext.setDevice(d), canExit: !configuration.forceFullscreen, onExit: () => setFullscreen(false), firstMobileDeviceName: configuration.devices[0]?.name })] }), showFullscreenHint && !configuration.forceFullscreen && (_jsx("div", { className: "fixed inset-0", onMouseMoveCapture: () => {
+    const editorUi = fullscreen ? (_jsxs(_Fragment, { children: [_jsxs("div", { className: "fixed inset-0 flex", children: [_jsx(PageViewerFrame, { compareView: compareMode, pageViewContext: activePageViewContext }), _jsx(FullscreenControls, { device: activePageViewContext.device, setDevice: (d) => activePageViewContext.setDevice(d), canExit: !configuration.forceFullscreen, onExit: () => setFullscreen(false), firstMobileDeviceName: configuration.devices[0]?.name })] }), showFullscreenHint && !configuration.forceFullscreen && !isMobile && (_jsx("div", { className: "fixed inset-0 z-10000", onMouseMoveCapture: () => {
                     setTimeout(() => {
                         setShowFullscreenHint(false);
                     }, 600);
-                }, "data-testid": "fullscreen-hint-overlay", children: _jsxs("div", { className: "fixed top-6 left-1/2 -translate-x-1/2 transform rounded-full bg-black/60 px-6 py-2.5 text-sm font-medium text-white shadow-2xl backdrop-blur-md transition-all duration-500", children: ["Press", " ", _jsx("kbd", { className: "mx-1 rounded bg-white/20 px-1.5 py-0.5 text-xs font-semibold", children: "Ctrl + F11" }), " ", "to exit fullscreen"] }) }))] })) : (_jsxs(_Fragment, { children: [_jsx(EditorChrome, { className: className, currentWorkspace: currentWorkspace, centerPanelView: centerPanelView, editContext: editContext, showComponentNavigator: showComponentNavigator, handleSetShowComponentNavigator: handleSetShowComponentNavigator, showAgentsPanel: showAgentsPanel, handleSetShowAgentsPanel: handleSetShowAgentsPanel, workspaceId: workspaceId, 
-                // Legacy props for backwards compatibility
-                currentView: currentView, viewName: viewName }), isTourActive && (_jsx(Tour, { tourStopCallback: () => {
+                }, "data-testid": "fullscreen-hint-overlay", children: _jsxs("div", { className: "fixed top-6 left-1/2 -translate-x-1/2 transform rounded-full bg-black/60 px-6 py-2.5 text-sm font-medium text-white shadow-2xl backdrop-blur-md transition-all duration-500", children: ["Press", " ", _jsx("kbd", { className: "mx-1 rounded bg-white/20 px-1.5 py-0.5 text-xs font-semibold", children: "Ctrl + F11" }), " ", "to exit fullscreen"] }) }))] })) : (_jsxs(_Fragment, { children: [_jsx(EditorChrome, { className: className, currentWorkspace: currentWorkspace, centerPanelView: centerPanelView, editContext: editContext, showAgentsPanel: showAgentsPanel, handleSetShowAgentsPanel: handleSetShowAgentsPanel, workspaceId: workspaceId }), isTourActive && (_jsx(Tour, { tourStopCallback: () => {
                     setIsTourActive(false);
                     // Remove tour state from URL
                     // Use history.replaceState instead of router.replace to avoid triggering React navigation
@@ -4119,8 +4799,14 @@ export function EditorShell({ configuration, className, item: loadItemDescriptor
                     const newUrl = queryString
                         ? `${window.location.pathname}?${queryString}`
                         : window.location.pathname;
-                    window.history.replaceState(null, "", newUrl);
-                }, configuration: configuration, restoredFromUrl: tourRestoredRef.current })), _jsx(GuidanceOverlay, {}), _jsx(AgentDialogHandler, { sendWebSocketMessage: (type, payload) => sendSocketMessage({ type, payload }) })] }));
-    return (_jsx("div", { className: `editor h-full w-full`, children: _jsx(OperationsContextProvider, { value: operationsContext.context, children: _jsx(FieldsEditContextProvider, { value: fieldsEditContext, children: _jsxs(EditContextProvider, { value: editContext, children: [_jsx(DevModeIndicator, {}), startupChecks.state === "loading" && (_jsx("div", { className: "fixed inset-0 z-50 flex items-center justify-center bg-white/70 backdrop-blur-[1px]", children: _jsx("div", { className: "flex items-center gap-3 rounded-md border border-gray-200 bg-white px-4 py-3 text-gray-700 shadow-sm", children: _jsx(Spinner, { size: "xl" }) }) })), editContext.isRefreshing && (_jsx("div", { className: "pointer-events-none fixed right-0 bottom-0 flex h-24 w-24 items-center justify-center text-gray-600 opacity-50 select-none", children: _jsx(Spinner, {}) })), children || editorUi, dialog, _jsx(Toaster, { position: "top-center" }), " ", _jsx(ConfirmationDialog, { ref: confirmationDialogRef }), _jsx(QuickItemSwitcher, { visible: quickSwitcherVisible, entries: navigationHistory.slice(0, 5), selectedIndex: quickSwitcherSelectedIndex, onSelect: handleQuickSwitcherSelect, onClose: () => setQuickSwitcherVisible(false) }), _jsx(EditContextMenu, { ref: contextMenuRef }), _jsx(InlineAiTrigger, {}), media.mediaSelectorVisible && (_jsx(MediaSelector, { language: editContext.currentItemDescriptor.language, visible: media.mediaSelectorVisible, onHide: media.handleHide, onMediaSelected: media.onMediaSelect, selectedIdPath: media.selectedMediaIdPath, mode: media.mediaSelectorMode, initialSearchTerm: media.initialSearchTerm })), _jsx(FieldEditorPopup, { ref: fieldEditorPopupRef })] }) }) }) }));
+                    window.history.replaceState(getCurrentHistoryState(), "", newUrl);
+                }, configuration: configuration, restoredFromUrl: tourRestoredRef.current })), _jsx(FeatureGate, { feature: LicenseFeatures.AI, children: _jsx(GuidanceOverlay, {}) }), _jsx(FeatureGate, { feature: LicenseFeatures.AI, children: _jsx(AgentDialogHandler, {}) })] }));
+    return (_jsx(LicenseProvider, { initialLicenseStatus: initialLicenseStatus, initialStatusLoaded: initialLicenseStatusLoaded, children: _jsx("div", { className: `editor h-full w-full`, children: _jsx(OperationsContextProvider, { value: operationsContext.context, children: _jsx(FieldsEditContextProvider, { value: fieldsEditContext, children: _jsxs(EditContextProvider, { value: editContext, children: [_jsx(DevModeIndicator, {}), startupChecks.state === "loading" && (_jsx("div", { className: "fixed inset-0 z-50 flex items-center justify-center bg-white/70 backdrop-blur-[1px]", children: _jsx("div", { className: "flex items-center gap-3 rounded-md border border-gray-200 bg-white px-4 py-3 text-gray-700 shadow-sm", children: _jsx(Spinner, { size: "xl" }) }) })), editContext.isRefreshing && (_jsx("div", { className: "pointer-events-none fixed right-0 bottom-0 flex h-24 w-24 items-center justify-center text-gray-600 opacity-50 select-none", children: _jsx(Spinner, {}) })), (currentWorkspace.id === "agents" ||
+                                currentWorkspace.id === "taskboard") &&
+                                showAgentsWorkspaceEditor && (_jsx(AgentsSlotContextBridgeHost, { slots: editorSlots })), startupChecks.state !== "loading" && (children || editorUi), startupChecks.state !== "loading" && dialog, _jsx(Toaster, { position: "top-center" }), " ", _jsx(ConfirmationDialog, { ref: confirmationDialogRef }), _jsx(ConcurrentUserLimitDialog, { open: concurrentUserLimitError !== null, onOpenChange: (open) => {
+                                    if (!open) {
+                                        setConcurrentUserLimitError(null);
+                                    }
+                                }, sessionId: sessionId, currentUsers: concurrentUserLimitError?.currentUsers ?? 0, maxUsers: concurrentUserLimitError?.maxUsers ?? 0, message: concurrentUserLimitError?.message ?? "", onRetry: handleRetryConnection, isAdministrator: userInfo.user.isAdministrator === true }), _jsx(QuickItemSwitcher, { visible: quickSwitcherVisible, entries: quickSwitcherEntries.slice(0, 5), selectedIndex: quickSwitcherSelectedIndex, onSelect: handleQuickSwitcherSelect, onClose: () => setQuickSwitcherVisible(false) }), _jsx(EditContextMenu, { ref: contextMenuRef }), _jsx(EditorFormHintPopover, {}), _jsx(FeatureGate, { feature: LicenseFeatures.AI, children: _jsx(InlineAiTrigger, {}) }), media.mediaSelectorVisible && (_jsx(MediaSelector, { language: editContext.currentItemDescriptor.language, visible: media.mediaSelectorVisible, onHide: media.handleHide, onMediaSelected: media.onMediaSelect, selectedIdPath: media.selectedMediaIdPath, mode: media.mediaSelectorMode, initialSearchTerm: media.initialSearchTerm })), _jsx(FieldEditorPopup, { ref: fieldEditorPopupRef }), _jsx(LicenseOverlay, {})] }) }) }) }) }));
 }
 //# sourceMappingURL=EditorShell.js.map