diff --git a/src/browser/App.tsx b/src/browser/App.tsx
index d99d1079f4..27885d39e5 100644
--- a/src/browser/App.tsx
+++ b/src/browser/App.tsx
@@ -17,7 +17,7 @@ import {
   readPersistedState,
 } from "./hooks/usePersistedState";
 import { useResizableSidebar } from "./hooks/useResizableSidebar";
-import { matchesKeybind, KEYBINDS } from "./utils/ui/keybinds";
+import { matchesKeybind, KEYBINDS, isEditableElement } from "./utils/ui/keybinds";
 import { handleLayoutSlotHotkeys } from "./utils/ui/layoutSlotHotkeys";
 import { buildSortedWorkspacesByProject } from "./utils/ui/workspaceFiltering";
 import { getVisibleWorkspaceIds } from "./utils/ui/workspaceDomNav";
@@ -90,7 +90,7 @@ function AppInner() {
     loading,
     setWorkspaceMetadata,
     removeWorkspace,
-    renameWorkspace,
+    updateWorkspaceTitle,
     refreshWorkspaceMetadata,
     selectedWorkspace,
     setSelectedWorkspace,
@@ -555,9 +555,9 @@ function AppInner() {
     [removeWorkspace]
   );
 
-  const renameWorkspaceFromPalette = useCallback(
-    async (workspaceId: string, newName: string) => renameWorkspace(workspaceId, newName),
-    [renameWorkspace]
+  const updateTitleFromPalette = useCallback(
+    async (workspaceId: string, newTitle: string) => updateWorkspaceTitle(workspaceId, newTitle),
+    [updateWorkspaceTitle]
   );
 
   const addProjectFromPalette = useCallback(() => {
@@ -594,7 +594,7 @@ function AppInner() {
     getBranchesForProject,
     onSelectWorkspace: selectWorkspaceFromPalette,
     onRemoveWorkspace: removeWorkspaceFromPalette,
-    onRenameWorkspace: renameWorkspaceFromPalette,
+    onUpdateTitle: updateTitleFromPalette,
     onAddProject: addProjectFromPalette,
     onRemoveProject: removeProjectFromPalette,
     onToggleSidebar: toggleSidebarFromPalette,
@@ -659,12 +659,26 @@ function AppInner() {
   // Handle keyboard shortcuts
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.defaultPrevented) {
+        return;
+      }
+
       if (matchesKeybind(e, KEYBINDS.NEXT_WORKSPACE)) {
         e.preventDefault();
         handleNavigateWorkspace("next");
       } else if (matchesKeybind(e, KEYBINDS.PREV_WORKSPACE)) {
         e.preventDefault();
         handleNavigateWorkspace("prev");
+      } else if (
+        matchesKeybind(e, KEYBINDS.OPEN_COMMAND_PALETTE_ALT) &&
+        !sidebarCollapsed &&
+        selectedWorkspace &&
+        selectedWorkspace.workspaceId !== MUX_HELP_CHAT_WORKSPACE_ID &&
+        !isEditableElement(e.target)
+      ) {
+        // F2 edits the selected workspace title in the expanded sidebar; skip
+        // command palette handling so both shortcuts don't fire.
+        return;
       } else if (
         matchesKeybind(e, KEYBINDS.OPEN_COMMAND_PALETTE) ||
         matchesKeybind(e, KEYBINDS.OPEN_COMMAND_PALETTE_ALT)
@@ -704,10 +718,12 @@ function AppInner() {
     handleNavigateWorkspace,
     handleOpenMuxChat,
     setSidebarCollapsed,
+    sidebarCollapsed,
     isCommandPaletteOpen,
     closeCommandPalette,
     openCommandPalette,
     creationProjectPath,
+    selectedWorkspace,
     openSettings,
     navigate,
   ]);
diff --git a/src/browser/components/ChatInputToasts.tsx b/src/browser/components/ChatInputToasts.tsx
index 22f2cc2728..b7f1ef48d8 100644
--- a/src/browser/components/ChatInputToasts.tsx
+++ b/src/browser/components/ChatInputToasts.tsx
@@ -63,26 +63,6 @@ export const createCommandToast = (parsed: ParsedCommand): Toast | null => {
         ),
       };
 
-    case "fork-help":
-      return {
-        id: Date.now().toString(),
-        type: "error",
-        title: "Fork Command",
-        message: "Fork current workspace with a new name",
-        solution: (
-          <>
-            <SolutionLabel>Usage:</SolutionLabel>
-            /fork &lt;new-name&gt; [optional start message]
-            <br />
-            <br />
-            <SolutionLabel>Examples:</SolutionLabel>
-            /fork experiment-branch
-            <br />
-            /fork refactor Continue with refactoring approach
-          </>
-        ),
-      };
-
     case "command-missing-args":
       return {
         id: Date.now().toString(),
diff --git a/src/browser/components/ProjectSidebar.tsx b/src/browser/components/ProjectSidebar.tsx
index e920c8ad5d..8319df452c 100644
--- a/src/browser/components/ProjectSidebar.tsx
+++ b/src/browser/components/ProjectSidebar.tsx
@@ -25,7 +25,14 @@ import {
   reorderProjects,
   normalizeOrder,
 } from "@/common/utils/projectOrdering";
-import { matchesKeybind, formatKeybind, KEYBINDS } from "@/browser/utils/ui/keybinds";
+import {
+  matchesKeybind,
+  formatKeybind,
+  isEditableElement,
+  KEYBINDS,
+} from "@/browser/utils/ui/keybinds";
+import { useAPI } from "@/browser/contexts/API";
+import { CUSTOM_EVENTS, type CustomEventType } from "@/common/constants/events";
 import { PlatformPaths } from "@/common/utils/paths";
 import {
   partitionWorkspacesByAge,
@@ -47,13 +54,14 @@ import type { Secret } from "@/common/types/secrets";
 
 import { WorkspaceListItem, type WorkspaceSelection } from "./WorkspaceListItem";
 import { WorkspaceStatusIndicator } from "./WorkspaceStatusIndicator";
-import { RenameProvider } from "@/browser/contexts/WorkspaceRenameContext";
+import { TitleEditProvider, useTitleEdit } from "@/browser/contexts/WorkspaceTitleEditContext";
 import { useProjectContext } from "@/browser/contexts/ProjectContext";
 import { ChevronRight, CircleHelp, KeyRound } from "lucide-react";
 import { MUX_HELP_CHAT_WORKSPACE_ID } from "@/common/constants/muxChat";
 import { useWorkspaceActions } from "@/browser/contexts/WorkspaceContext";
 import { useRouter } from "@/browser/contexts/RouterContext";
 import { usePopoverError } from "@/browser/hooks/usePopoverError";
+import { forkWorkspace } from "@/browser/utils/chatCommands";
 import { PopoverError } from "./PopoverError";
 import { SectionHeader } from "./SectionHeader";
 import { AddSectionButton } from "./AddSectionButton";
@@ -319,6 +327,86 @@ function MuxChatStatusIndicator() {
   );
 }
 
+/**
+ * Handles F2 (edit title) and Shift+F2 (generate new title) keybinds.
+ * Rendered inside TitleEditProvider so it can access useTitleEdit().
+ */
+function SidebarTitleEditKeybinds(props: {
+  selectedWorkspace: WorkspaceSelection | undefined;
+  sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
+  collapsed: boolean;
+}) {
+  const { requestEdit, wrapGenerateTitle } = useTitleEdit();
+  const { api } = useAPI();
+
+  const regenerateTitleForWorkspace = useCallback(
+    (workspaceId: string) => {
+      if (workspaceId === MUX_HELP_CHAT_WORKSPACE_ID) {
+        return;
+      }
+      wrapGenerateTitle(workspaceId, () => {
+        if (!api) {
+          return Promise.resolve({ success: false, error: "Not connected to server" });
+        }
+        return api.workspace.regenerateTitle({ workspaceId });
+      });
+    },
+    [wrapGenerateTitle, api]
+  );
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (props.collapsed) return;
+      if (!props.selectedWorkspace) return;
+      if (isEditableElement(e.target)) return;
+      const wsId = props.selectedWorkspace.workspaceId;
+      if (wsId === MUX_HELP_CHAT_WORKSPACE_ID) return;
+
+      if (matchesKeybind(e, KEYBINDS.EDIT_WORKSPACE_TITLE)) {
+        e.preventDefault();
+        const meta = props.sortedWorkspacesByProject
+          .get(props.selectedWorkspace.projectPath)
+          ?.find((m) => m.id === wsId);
+        const displayTitle = meta?.title ?? meta?.name ?? "";
+        requestEdit(wsId, displayTitle);
+      } else if (matchesKeybind(e, KEYBINDS.GENERATE_WORKSPACE_TITLE)) {
+        e.preventDefault();
+        regenerateTitleForWorkspace(wsId);
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [
+    props.collapsed,
+    props.selectedWorkspace,
+    props.sortedWorkspacesByProject,
+    requestEdit,
+    regenerateTitleForWorkspace,
+  ]);
+
+  useEffect(() => {
+    const handleGenerateTitleRequest: EventListener = (event) => {
+      const customEvent = event as CustomEventType<
+        typeof CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED
+      >;
+      regenerateTitleForWorkspace(customEvent.detail.workspaceId);
+    };
+
+    window.addEventListener(
+      CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED,
+      handleGenerateTitleRequest
+    );
+    return () => {
+      window.removeEventListener(
+        CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED,
+        handleGenerateTitleRequest
+      );
+    };
+  }, [regenerateTitleForWorkspace]);
+
+  return null;
+}
+
 interface ProjectSidebarProps {
   collapsed: boolean;
   onToggleCollapsed: () => void;
@@ -344,7 +432,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
     setSelectedWorkspace: onSelectWorkspace,
     archiveWorkspace: onArchiveWorkspace,
     removeWorkspace,
-    renameWorkspace: onRenameWorkspace,
+    updateWorkspaceTitle: onUpdateTitle,
     refreshWorkspaceMetadata,
     pendingNewWorkspaceProject,
     pendingNewWorkspaceDraftId,
@@ -356,6 +444,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
   } = useWorkspaceActions();
   const workspaceStore = useWorkspaceStoreRaw();
   const { navigateToProject } = useRouter();
+  const { api } = useAPI();
 
   // Get project state and operations from context
   const {
@@ -467,6 +556,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
   const [archivingWorkspaceIds, setArchivingWorkspaceIds] = useState<Set<string>>(new Set());
   const [removingWorkspaceIds, setRemovingWorkspaceIds] = useState<Set<string>>(new Set());
   const workspaceArchiveError = usePopoverError();
+  const workspaceForkError = usePopoverError();
   const workspaceRemoveError = usePopoverError();
   const [archiveConfirmation, setArchiveConfirmation] = useState<{
     workspaceId: string;
@@ -522,6 +612,40 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
     }
   };
 
+  const handleForkWorkspace = useCallback(
+    async (workspaceId: string, buttonElement?: HTMLElement) => {
+      if (!api) {
+        workspaceForkError.showError(workspaceId, "Not connected to server");
+        return;
+      }
+
+      let anchor: { top: number; left: number } | undefined;
+      if (buttonElement) {
+        const rect = buttonElement.getBoundingClientRect();
+        anchor = {
+          top: rect.top + window.scrollY,
+          left: rect.right + 10,
+        };
+      }
+
+      try {
+        const result = await forkWorkspace({
+          client: api,
+          sourceWorkspaceId: workspaceId,
+        });
+        if (result.success) {
+          return;
+        }
+        workspaceForkError.showError(workspaceId, result.error ?? "Failed to fork chat", anchor);
+      } catch (error) {
+        // IPC/transport failures throw instead of returning { success: false }
+        const message = error instanceof Error ? error.message : String(error);
+        workspaceForkError.showError(workspaceId, message, anchor);
+      }
+    },
+    [api, workspaceForkError]
+  );
+
   const performArchiveWorkspace = useCallback(
     async (workspaceId: string, buttonElement?: HTMLElement) => {
       // Mark workspace as being archived for UI feedback
@@ -740,7 +864,12 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
   }, [selectedWorkspace, handleAddWorkspace, handleArchiveWorkspace]);
 
   return (
-    <RenameProvider onRenameWorkspace={onRenameWorkspace}>
+    <TitleEditProvider onUpdateTitle={onUpdateTitle}>
+      <SidebarTitleEditKeybinds
+        selectedWorkspace={selectedWorkspace ?? undefined}
+        sortedWorkspacesByProject={sortedWorkspacesByProject}
+        collapsed={collapsed}
+      />
       <DndProvider backend={HTML5Backend}>
         <ProjectDragLayer />
         <WorkspaceDragLayer />
@@ -1011,6 +1140,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
                                     metadata.isRemoving === true
                                   }
                                   onSelectWorkspace={handleSelectWorkspace}
+                                  onForkWorkspace={handleForkWorkspace}
                                   onArchiveWorkspace={handleArchiveWorkspace}
                                   onCancelCreation={handleCancelWorkspaceCreation}
                                   depth={depthByWorkspaceId[metadata.id] ?? 0}
@@ -1377,6 +1507,11 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
             prefix="Failed to archive chat"
             onDismiss={workspaceArchiveError.clearError}
           />
+          <PopoverError
+            error={workspaceForkError.error}
+            prefix="Failed to fork chat"
+            onDismiss={workspaceForkError.clearError}
+          />
           <PopoverError
             error={workspaceRemoveError.error}
             prefix="Failed to cancel workspace creation"
@@ -1394,7 +1529,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
           />
         </div>
       </DndProvider>
-    </RenameProvider>
+    </TitleEditProvider>
   );
 };
 
diff --git a/src/browser/components/Settings/sections/KeybindsSection.tsx b/src/browser/components/Settings/sections/KeybindsSection.tsx
index 67743f1e05..025778738b 100644
--- a/src/browser/components/Settings/sections/KeybindsSection.tsx
+++ b/src/browser/components/Settings/sections/KeybindsSection.tsx
@@ -17,6 +17,8 @@ const KEYBIND_LABELS: Record<keyof typeof KEYBINDS, string> = {
   FOCUS_INPUT_I: "Focus input (i)",
   FOCUS_INPUT_A: "Focus input (a)",
   NEW_WORKSPACE: "New workspace",
+  EDIT_WORKSPACE_TITLE: "Edit workspace title",
+  GENERATE_WORKSPACE_TITLE: "Generate new title",
   ARCHIVE_WORKSPACE: "Archive workspace",
   JUMP_TO_BOTTOM: "Jump to bottom",
   NEXT_WORKSPACE: "Next workspace",
@@ -99,6 +101,8 @@ const KEYBIND_GROUPS: Array<{ label: string; keys: Array<keyof typeof KEYBINDS>
     label: "Navigation",
     keys: [
       "NEW_WORKSPACE",
+      "EDIT_WORKSPACE_TITLE",
+      "GENERATE_WORKSPACE_TITLE",
       "ARCHIVE_WORKSPACE",
       "NEXT_WORKSPACE",
       "PREV_WORKSPACE",
diff --git a/src/browser/components/WorkspaceListItem.tsx b/src/browser/components/WorkspaceListItem.tsx
index 9eea57ddd6..d76d682c52 100644
--- a/src/browser/components/WorkspaceListItem.tsx
+++ b/src/browser/components/WorkspaceListItem.tsx
@@ -1,4 +1,4 @@
-import { useRename } from "@/browser/contexts/WorkspaceRenameContext";
+import { useTitleEdit } from "@/browser/contexts/WorkspaceTitleEditContext";
 import { stopKeyboardPropagation } from "@/browser/utils/events";
 import { cn } from "@/common/lib/utils";
 import { useGitStatus } from "@/browser/stores/GitStatusStore";
@@ -16,7 +16,7 @@ import { WorkspaceHoverPreview } from "./WorkspaceHoverPreview";
 import { Tooltip, TooltipTrigger, TooltipContent } from "./ui/tooltip";
 import { HoverCard, HoverCardTrigger, HoverCardContent } from "./ui/hover-card";
 import { Popover, PopoverContent, PopoverTrigger, PopoverAnchor } from "./ui/popover";
-import { Pencil, Trash2, Ellipsis, Loader2, Link2 } from "lucide-react";
+import { Pencil, Trash2, Ellipsis, Loader2, Link2, Sparkles, GitBranch } from "lucide-react";
 import { WorkspaceStatusIndicator } from "./WorkspaceStatusIndicator";
 import { Shimmer } from "./ai-elements/shimmer";
 import { ArchiveIcon } from "./icons/ArchiveIcon";
@@ -24,6 +24,7 @@ import { WORKSPACE_DRAG_TYPE, type WorkspaceDragItem } from "./WorkspaceSectionD
 import { useLinkSharingEnabled } from "@/browser/contexts/TelemetryEnabledContext";
 import { formatKeybind, KEYBINDS } from "@/browser/utils/ui/keybinds";
 import { ShareTranscriptDialog } from "./ShareTranscriptDialog";
+import { useAPI } from "@/browser/contexts/API";
 
 const RADIX_PORTAL_WRAPPER_SELECTOR = "[data-radix-popper-content-wrapper]" as const;
 
@@ -75,6 +76,7 @@ export interface WorkspaceListItemProps extends WorkspaceListItemBaseProps {
   /** Section ID this workspace belongs to (for drag-drop targeting) */
   sectionId?: string;
   onSelectWorkspace: (selection: WorkspaceSelection) => void;
+  onForkWorkspace: (workspaceId: string, button: HTMLElement) => Promise<void>;
   onArchiveWorkspace: (workspaceId: string, button: HTMLElement) => Promise<void>;
   onCancelCreation: (workspaceId: string) => Promise<void>;
 }
@@ -348,6 +350,7 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
     depth,
     sectionId,
     onSelectWorkspace,
+    onForkWorkspace,
     onArchiveWorkspace,
     onCancelCreation,
   } = props;
@@ -362,8 +365,17 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
   const { isUnread } = useWorkspaceUnread(workspaceId);
   const gitStatus = useGitStatus(workspaceId);
 
-  // Get title edit context (renamed from rename context since we now edit titles, not names)
-  const { editingWorkspaceId, requestRename, confirmRename, cancelRename } = useRename();
+  // Get title edit context — manages inline title editing state across the sidebar
+  const {
+    editingWorkspaceId,
+    requestEdit,
+    confirmEdit,
+    cancelEdit,
+    generatingTitleWorkspaceIds,
+    wrapGenerateTitle,
+  } = useTitleEdit();
+  const isGeneratingTitle = generatingTitleWorkspaceIds.has(workspaceId);
+  const { api } = useAPI();
 
   // Local state for title editing
   const [editingTitle, setEditingTitle] = useState<string>("");
@@ -394,6 +406,15 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
     }
   }, [isEditing]);
 
+  const wasEditingRef = useRef(false);
+  useEffect(() => {
+    if (isEditing && !wasEditingRef.current) {
+      setEditingTitle(displayTitle);
+      setTitleError(null);
+    }
+    wasEditingRef.current = isEditing;
+  }, [isEditing, displayTitle]);
+
   // Clean up long-press timer on unmount
   useEffect(() => {
     return () => {
@@ -407,7 +428,7 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
   // so it works even when the sidebar is collapsed and list items are unmounted.
 
   const startEditing = () => {
-    if (requestRename(workspaceId, displayTitle)) {
+    if (requestEdit(workspaceId, displayTitle)) {
       setEditingTitle(displayTitle);
       setTitleError(null);
     }
@@ -419,7 +440,7 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
       return;
     }
 
-    const result = await confirmRename(workspaceId, editingTitle);
+    const result = await confirmEdit(workspaceId, editingTitle);
     if (!result.success) {
       setTitleError(result.error ?? "Failed to update title");
     } else {
@@ -428,7 +449,7 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
   };
 
   const handleCancelEdit = () => {
-    cancelRename();
+    cancelEdit();
     setEditingTitle("");
     setTitleError(null);
   };
@@ -695,9 +716,53 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
                   >
                     <span className="flex items-center gap-2">
                       <Pencil className="h-3 w-3 shrink-0" />
-                      Edit chat title
+                      Edit chat title{" "}
+                      <span className="text-muted text-[10px]">
+                        ({formatKeybind(KEYBINDS.EDIT_WORKSPACE_TITLE)})
+                      </span>
+                    </span>
+                  </button>
+                  <button
+                    className="text-foreground bg-background hover:bg-hover w-full rounded-sm px-2 py-1.5 text-left text-xs whitespace-nowrap"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      setIsTitleMenuOpen(false);
+                      wrapGenerateTitle(workspaceId, () => {
+                        if (!api) {
+                          return Promise.resolve({
+                            success: false,
+                            error: "Not connected to server",
+                          });
+                        }
+                        return api.workspace.regenerateTitle({ workspaceId });
+                      });
+                    }}
+                  >
+                    <span className="flex items-center gap-2">
+                      <Sparkles className="h-3 w-3 shrink-0" />
+                      Generate new title{" "}
+                      <span className="text-muted text-[10px]">
+                        ({formatKeybind(KEYBINDS.GENERATE_WORKSPACE_TITLE)})
+                      </span>
                     </span>
                   </button>
+                  {!isMuxHelpChat && (
+                    // Expose fork in the row menu so users can quickly branch off a chat
+                    // without needing to remember the /fork slash command.
+                    <button
+                      className="text-foreground bg-background hover:bg-hover w-full rounded-sm px-2 py-1.5 text-left text-xs whitespace-nowrap"
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        setIsTitleMenuOpen(false);
+                        void onForkWorkspace(workspaceId, e.currentTarget);
+                      }}
+                    >
+                      <span className="flex items-center gap-2">
+                        <GitBranch className="h-3 w-3 shrink-0" />
+                        Fork chat
+                      </span>
+                    </button>
+                  )}
                   {/* Share transcript link (gated on telemetry/link-sharing being enabled). */}
                   {linkSharingEnabled === true && !isMuxHelpChat && (
                     <button
@@ -780,7 +845,8 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
                   <span
                     className={cn(
                       "text-foreground block truncate text-left text-[13px] transition-colors duration-200",
-                      !isDisabled && "cursor-pointer"
+                      !isDisabled && "cursor-pointer",
+                      isGeneratingTitle && "italic"
                     )}
                     onDoubleClick={(e) => {
                       if (isDisabled) return;
@@ -792,7 +858,7 @@ function RegularWorkspaceListItemInner(props: WorkspaceListItemProps) {
                     <Shimmer
                       className={cn(
                         "w-full truncate",
-                        !(isWorking || isInitializing) && "no-shimmer"
+                        !(isWorking || isInitializing || isGeneratingTitle) && "no-shimmer"
                       )}
                       colorClass="var(--color-foreground)"
                     >
diff --git a/src/browser/contexts/WorkspaceContext.test.tsx b/src/browser/contexts/WorkspaceContext.test.tsx
index 180cae0ffb..a7a74c2bfd 100644
--- a/src/browser/contexts/WorkspaceContext.test.tsx
+++ b/src/browser/contexts/WorkspaceContext.test.tsx
@@ -574,7 +574,7 @@ describe("WorkspaceContext", () => {
     expect(result.error).toBe("Failed");
   });
 
-  test("renameWorkspace updates workspace title (now uses updateTitle API)", async () => {
+  test("updateWorkspaceTitle updates workspace title via updateTitle API", async () => {
     const initialWorkspaces = [
       createWorkspaceMetadata({
         id: "ws-title-edit",
@@ -610,7 +610,7 @@ describe("WorkspaceContext", () => {
       }),
     ]);
 
-    await ctx().renameWorkspace("ws-title-edit", "New Title");
+    await ctx().updateWorkspaceTitle("ws-title-edit", "New Title");
 
     expect(workspaceApi.updateTitle).toHaveBeenCalledWith({
       workspaceId: "ws-title-edit",
@@ -618,7 +618,7 @@ describe("WorkspaceContext", () => {
     });
   });
 
-  test("renameWorkspace handles failure gracefully", async () => {
+  test("updateWorkspaceTitle handles failure gracefully", async () => {
     const { workspace: workspaceApi } = createMockAPI();
 
     const ctx = await setup();
@@ -628,7 +628,7 @@ describe("WorkspaceContext", () => {
       error: "Failed",
     });
 
-    const result = await ctx().renameWorkspace("ws-1", "new");
+    const result = await ctx().updateWorkspaceTitle("ws-1", "new");
     expect(result.success).toBe(false);
     expect(result.error).toBe("Failed");
   });
diff --git a/src/browser/contexts/WorkspaceContext.tsx b/src/browser/contexts/WorkspaceContext.tsx
index bea5db3d5b..4f421e3ee7 100644
--- a/src/browser/contexts/WorkspaceContext.tsx
+++ b/src/browser/contexts/WorkspaceContext.tsx
@@ -404,9 +404,9 @@ export interface WorkspaceContext extends WorkspaceMetadataContextValue {
     workspaceId: string,
     options?: { force?: boolean }
   ) => Promise<{ success: boolean; error?: string }>;
-  renameWorkspace: (
+  updateWorkspaceTitle: (
     workspaceId: string,
-    newName: string
+    newTitle: string
   ) => Promise<{ success: boolean; error?: string }>;
   archiveWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
   unarchiveWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
@@ -1234,7 +1234,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
    * We just reload metadata after the update - no need to update selectedWorkspace
    * since the ID stays the same and the metadata map refresh handles the title update.
    */
-  const renameWorkspace = useCallback(
+  const updateWorkspaceTitle = useCallback(
     async (
       workspaceId: string,
       newTitle: string
@@ -1515,7 +1515,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
     () => ({
       createWorkspace,
       removeWorkspace,
-      renameWorkspace,
+      updateWorkspaceTitle,
       archiveWorkspace,
       unarchiveWorkspace,
       refreshWorkspaceMetadata,
@@ -1538,7 +1538,7 @@ export function WorkspaceProvider(props: WorkspaceProviderProps) {
     [
       createWorkspace,
       removeWorkspace,
-      renameWorkspace,
+      updateWorkspaceTitle,
       archiveWorkspace,
       unarchiveWorkspace,
       refreshWorkspaceMetadata,
diff --git a/src/browser/contexts/WorkspaceRenameContext.tsx b/src/browser/contexts/WorkspaceRenameContext.tsx
deleted file mode 100644
index 555da6889d..0000000000
--- a/src/browser/contexts/WorkspaceRenameContext.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-import React, { createContext, useContext, useState, useCallback } from "react";
-
-interface RenameResult {
-  success: boolean;
-  error?: string;
-}
-
-interface RenameContextValue {
-  editingWorkspaceId: string | null;
-  requestRename: (workspaceId: string, currentName: string) => boolean;
-  confirmRename: (workspaceId: string, newName: string) => Promise<RenameResult>;
-  cancelRename: () => void;
-}
-
-const RenameContext = createContext<RenameContextValue | null>(null);
-
-interface RenameProviderProps {
-  children: React.ReactNode;
-  onRenameWorkspace: (
-    workspaceId: string,
-    newName: string
-  ) => Promise<{ success: boolean; error?: string }>;
-}
-
-export const RenameProvider: React.FC<RenameProviderProps> = ({ children, onRenameWorkspace }) => {
-  const [editingWorkspaceId, setEditingWorkspaceId] = useState<string | null>(null);
-  const [originalName, setOriginalName] = useState<string>("");
-
-  const requestRename = useCallback(
-    (workspaceId: string, currentName: string): boolean => {
-      // Only allow one workspace to be edited at a time
-      if (editingWorkspaceId !== null && editingWorkspaceId !== workspaceId) {
-        return false;
-      }
-
-      setEditingWorkspaceId(workspaceId);
-      setOriginalName(currentName);
-      return true;
-    },
-    [editingWorkspaceId]
-  );
-
-  const confirmRename = useCallback(
-    async (workspaceId: string, newName: string): Promise<RenameResult> => {
-      const trimmedName = newName.trim();
-
-      // Short-circuit if name hasn't changed
-      if (trimmedName === originalName) {
-        setEditingWorkspaceId(null);
-        setOriginalName("");
-        return { success: true };
-      }
-
-      if (!trimmedName) {
-        return { success: false, error: "Name cannot be empty" };
-      }
-
-      const result = await onRenameWorkspace(workspaceId, trimmedName);
-
-      if (result.success) {
-        setEditingWorkspaceId(null);
-        setOriginalName("");
-      }
-
-      return result;
-    },
-    [originalName, onRenameWorkspace]
-  );
-
-  const cancelRename = useCallback(() => {
-    setEditingWorkspaceId(null);
-    setOriginalName("");
-  }, []);
-
-  const value: RenameContextValue = {
-    editingWorkspaceId,
-    requestRename,
-    confirmRename,
-    cancelRename,
-  };
-
-  return <RenameContext.Provider value={value}>{children}</RenameContext.Provider>;
-};
-
-export const useRename = (): RenameContextValue => {
-  const context = useContext(RenameContext);
-  if (!context) {
-    throw new Error("useRename must be used within a RenameProvider");
-  }
-  return context;
-};
diff --git a/src/browser/contexts/WorkspaceTitleEditContext.test.tsx b/src/browser/contexts/WorkspaceTitleEditContext.test.tsx
new file mode 100644
index 0000000000..89f2768714
--- /dev/null
+++ b/src/browser/contexts/WorkspaceTitleEditContext.test.tsx
@@ -0,0 +1,192 @@
+import { act, cleanup, render, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { GlobalWindow } from "happy-dom";
+import type { Result } from "@/common/types/result";
+import { TitleEditProvider, useTitleEdit } from "./WorkspaceTitleEditContext";
+
+interface ContextProbeProps {
+  onValue: (value: ReturnType<typeof useTitleEdit>) => void;
+}
+
+function ContextProbe(props: ContextProbeProps): null {
+  const value = useTitleEdit();
+  props.onValue(value);
+  return null;
+}
+
+type RegenerateTitleResult = Result<{ title: string }, string>;
+
+function createDeferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
+  let resolve: ((value: T) => void) | undefined;
+  const promise = new Promise<T>((innerResolve) => {
+    resolve = innerResolve;
+  });
+
+  return {
+    promise,
+    resolve: (value: T) => resolve?.(value),
+  };
+}
+
+function isGeneratingTitle(
+  value: ReturnType<typeof useTitleEdit> | null,
+  workspaceId: string
+): boolean {
+  if (!value) {
+    return false;
+  }
+  return [...value.generatingTitleWorkspaceIds].includes(workspaceId);
+}
+
+describe("WorkspaceTitleEditContext", () => {
+  afterEach(() => {
+    cleanup();
+    globalThis.window = undefined as unknown as Window & typeof globalThis;
+    globalThis.document = undefined as unknown as Document;
+    globalThis.localStorage = undefined as unknown as Storage;
+    delete (globalThis as unknown as { alert?: typeof alert }).alert;
+  });
+
+  test("ignores duplicate regenerate requests while one is already in flight", async () => {
+    const testWindow = new GlobalWindow();
+    globalThis.window = testWindow as unknown as Window & typeof globalThis;
+    globalThis.document = testWindow.document as unknown as Document;
+    globalThis.localStorage = testWindow.localStorage as unknown as Storage;
+
+    let contextValue: ReturnType<typeof useTitleEdit> | null = null;
+
+    render(
+      <TitleEditProvider onUpdateTitle={() => Promise.resolve({ success: true })}>
+        <ContextProbe onValue={(value) => (contextValue = value)} />
+      </TitleEditProvider>
+    );
+
+    await waitFor(() => expect(contextValue).not.toBeNull());
+
+    const deferred = createDeferred<RegenerateTitleResult>();
+    const regenerate = mock(() => deferred.promise);
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-1", regenerate);
+      contextValue?.wrapGenerateTitle("ws-1", regenerate);
+    });
+
+    await waitFor(() => expect(regenerate).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(isGeneratingTitle(contextValue, "ws-1")).toBe(true));
+
+    act(() => {
+      deferred.resolve({ success: true, data: { title: "Regenerated" } });
+    });
+
+    await waitFor(() => expect(contextValue?.generatingTitleWorkspaceIds.size).toBe(0));
+
+    const completedResult: RegenerateTitleResult = {
+      success: true,
+      data: { title: "Regenerated again" },
+    };
+    const regenerateAfterComplete = mock(() => Promise.resolve(completedResult));
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-1", regenerateAfterComplete);
+    });
+
+    await waitFor(() => expect(regenerateAfterComplete).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(contextValue?.generatingTitleWorkspaceIds.size).toBe(0));
+  });
+
+  test("keeps loading state for other workspaces when one regeneration finishes", async () => {
+    const testWindow = new GlobalWindow();
+    globalThis.window = testWindow as unknown as Window & typeof globalThis;
+    globalThis.document = testWindow.document as unknown as Document;
+    globalThis.localStorage = testWindow.localStorage as unknown as Storage;
+
+    let contextValue: ReturnType<typeof useTitleEdit> | null = null;
+
+    render(
+      <TitleEditProvider onUpdateTitle={() => Promise.resolve({ success: true })}>
+        <ContextProbe onValue={(value) => (contextValue = value)} />
+      </TitleEditProvider>
+    );
+
+    await waitFor(() => expect(contextValue).not.toBeNull());
+
+    const deferredA = createDeferred<RegenerateTitleResult>();
+    const deferredB = createDeferred<RegenerateTitleResult>();
+    const regenerateA = mock(() => deferredA.promise);
+    const regenerateB = mock(() => deferredB.promise);
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-a", regenerateA);
+      contextValue?.wrapGenerateTitle("ws-b", regenerateB);
+    });
+
+    await waitFor(() => expect(isGeneratingTitle(contextValue, "ws-a")).toBe(true));
+    await waitFor(() => expect(isGeneratingTitle(contextValue, "ws-b")).toBe(true));
+
+    act(() => {
+      deferredB.resolve({ success: true, data: { title: "B" } });
+    });
+
+    await waitFor(() => expect(isGeneratingTitle(contextValue, "ws-b")).toBe(false));
+    expect(isGeneratingTitle(contextValue, "ws-a")).toBe(true);
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-a", regenerateA);
+    });
+    expect(regenerateA).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      deferredA.resolve({ success: true, data: { title: "A" } });
+    });
+
+    await waitFor(() => expect(contextValue?.generatingTitleWorkspaceIds.size).toBe(0));
+  });
+
+  test("clears in-flight state when regenerate callback throws synchronously", async () => {
+    const testWindow = new GlobalWindow();
+    globalThis.window = testWindow as unknown as Window & typeof globalThis;
+    globalThis.document = testWindow.document as unknown as Document;
+    globalThis.localStorage = testWindow.localStorage as unknown as Storage;
+
+    const alertMock = mock();
+    const alertHandler = (message?: unknown) => {
+      alertMock(message);
+    };
+    (testWindow as unknown as { alert: (message?: unknown) => void }).alert = alertHandler;
+    (globalThis as unknown as { alert: (message?: unknown) => void }).alert = alertHandler;
+
+    let contextValue: ReturnType<typeof useTitleEdit> | null = null;
+
+    render(
+      <TitleEditProvider onUpdateTitle={() => Promise.resolve({ success: true })}>
+        <ContextProbe onValue={(value) => (contextValue = value)} />
+      </TitleEditProvider>
+    );
+
+    await waitFor(() => expect(contextValue).not.toBeNull());
+
+    const thrown = mock(() => {
+      throw new Error("sync failure");
+    });
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-sync", thrown);
+    });
+
+    await waitFor(() => expect(contextValue?.generatingTitleWorkspaceIds.size).toBe(0));
+    await waitFor(() => expect(alertMock).toHaveBeenCalledWith("sync failure"));
+
+    const completedResult: RegenerateTitleResult = {
+      success: true,
+      data: { title: "Recovered" },
+    };
+    const regenerateAfterThrow = mock(() => Promise.resolve(completedResult));
+
+    act(() => {
+      contextValue?.wrapGenerateTitle("ws-sync", regenerateAfterThrow);
+    });
+
+    await waitFor(() => expect(regenerateAfterThrow).toHaveBeenCalledTimes(1));
+    await waitFor(() => expect(contextValue?.generatingTitleWorkspaceIds.size).toBe(0));
+  });
+});
diff --git a/src/browser/contexts/WorkspaceTitleEditContext.tsx b/src/browser/contexts/WorkspaceTitleEditContext.tsx
new file mode 100644
index 0000000000..a97c8cb566
--- /dev/null
+++ b/src/browser/contexts/WorkspaceTitleEditContext.tsx
@@ -0,0 +1,153 @@
+import React, { createContext, useContext, useState, useCallback, useRef } from "react";
+import type { Result } from "@/common/types/result";
+
+interface TitleEditResult {
+  success: boolean;
+  error?: string;
+}
+
+type RegenerateTitleResult = Result<{ title: string }, string>;
+
+interface TitleEditContextValue {
+  editingWorkspaceId: string | null;
+  requestEdit: (workspaceId: string, currentTitle: string) => boolean;
+  confirmEdit: (workspaceId: string, newTitle: string) => Promise<TitleEditResult>;
+  cancelEdit: () => void;
+  /** Workspace IDs whose titles are currently being generated by AI. */
+  generatingTitleWorkspaceIds: ReadonlySet<string>;
+  /** Wraps an async title-generation call with loading state management. */
+  wrapGenerateTitle: (workspaceId: string, fn: () => Promise<RegenerateTitleResult>) => void;
+}
+
+const TitleEditContext = createContext<TitleEditContextValue | null>(null);
+
+interface TitleEditProviderProps {
+  children: React.ReactNode;
+  onUpdateTitle: (
+    workspaceId: string,
+    newTitle: string
+  ) => Promise<{ success: boolean; error?: string }>;
+}
+
+export const TitleEditProvider: React.FC<TitleEditProviderProps> = ({
+  children,
+  onUpdateTitle,
+}) => {
+  const [editingWorkspaceId, setEditingWorkspaceId] = useState<string | null>(null);
+  const [originalTitle, setOriginalTitle] = useState<string>("");
+
+  const requestEdit = useCallback(
+    (workspaceId: string, currentTitle: string): boolean => {
+      // Only allow one workspace to be edited at a time
+      if (editingWorkspaceId !== null && editingWorkspaceId !== workspaceId) {
+        return false;
+      }
+
+      setEditingWorkspaceId(workspaceId);
+      setOriginalTitle(currentTitle);
+      return true;
+    },
+    [editingWorkspaceId]
+  );
+
+  const confirmEdit = useCallback(
+    async (workspaceId: string, newTitle: string): Promise<TitleEditResult> => {
+      const trimmedTitle = newTitle.trim();
+
+      // Short-circuit if title hasn't changed
+      if (trimmedTitle === originalTitle) {
+        setEditingWorkspaceId(null);
+        setOriginalTitle("");
+        return { success: true };
+      }
+
+      if (!trimmedTitle) {
+        return { success: false, error: "Title cannot be empty" };
+      }
+
+      const result = await onUpdateTitle(workspaceId, trimmedTitle);
+
+      if (result.success) {
+        setEditingWorkspaceId(null);
+        setOriginalTitle("");
+      }
+
+      return result;
+    },
+    [originalTitle, onUpdateTitle]
+  );
+
+  const cancelEdit = useCallback(() => {
+    setEditingWorkspaceId(null);
+    setOriginalTitle("");
+  }, []);
+
+  // --- Generate title loading state ---
+  const [generatingTitleWorkspaceIds, setGeneratingTitleWorkspaceIds] = useState<Set<string>>(
+    () => new Set()
+  );
+  const regeneratingWorkspaceIdsRef = useRef<Set<string>>(new Set());
+
+  const wrapGenerateTitle = useCallback(
+    (workspaceId: string, fn: () => Promise<RegenerateTitleResult>) => {
+      // Ignore duplicate triggers while a regeneration is already in flight for this workspace.
+      if (regeneratingWorkspaceIdsRef.current.has(workspaceId)) {
+        return;
+      }
+
+      regeneratingWorkspaceIdsRef.current.add(workspaceId);
+      setGeneratingTitleWorkspaceIds((current) => {
+        if (current.has(workspaceId)) {
+          return current;
+        }
+        const next = new Set(current);
+        next.add(workspaceId);
+        return next;
+      });
+
+      void Promise.resolve()
+        .then(() => fn())
+        .then((result) => {
+          if (!result.success && typeof window !== "undefined") {
+            window.alert(result.error);
+          }
+        })
+        .catch((error: unknown) => {
+          if (typeof window !== "undefined") {
+            window.alert(error instanceof Error ? error.message : String(error));
+          }
+        })
+        .finally(() => {
+          regeneratingWorkspaceIdsRef.current.delete(workspaceId);
+          setGeneratingTitleWorkspaceIds((current) => {
+            if (!current.has(workspaceId)) {
+              return current;
+            }
+            const next = new Set(current);
+            next.delete(workspaceId);
+            return next;
+          });
+        });
+    },
+    []
+  );
+
+  const value: TitleEditContextValue = {
+    editingWorkspaceId,
+    requestEdit,
+    confirmEdit,
+    cancelEdit,
+    generatingTitleWorkspaceIds,
+    wrapGenerateTitle,
+  };
+
+  return <TitleEditContext.Provider value={value}>{children}</TitleEditContext.Provider>;
+};
+
+export const useTitleEdit = (): TitleEditContextValue => {
+  const context = useContext(TitleEditContext);
+  if (!context) {
+    throw new Error("useTitleEdit must be used within a TitleEditProvider");
+  }
+  return context;
+};
diff --git a/src/browser/hooks/useWorkspaceName.ts b/src/browser/hooks/useWorkspaceName.ts
index 50f86d1845..facb37da12 100644
--- a/src/browser/hooks/useWorkspaceName.ts
+++ b/src/browser/hooks/useWorkspaceName.ts
@@ -3,8 +3,7 @@ import { z } from "zod";
 import { useAPI } from "@/browser/contexts/API";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { getWorkspaceNameStateKey } from "@/common/constants/storage";
-import { useGateway, formatAsGatewayModel } from "./useGatewayModels";
-import { getKnownModel } from "@/common/constants/knownModels";
+import { NAME_GEN_PREFERRED_MODELS } from "@/common/constants/nameGeneration";
 import type { NameGenerationError } from "@/common/types/errors";
 import { validateWorkspaceName } from "@/common/utils/validation/workspaceValidation";
 
@@ -14,34 +13,16 @@ export type WorkspaceNameUIError =
   | { kind: "validation"; message: string }
   | { kind: "transport"; message: string };
 
-/** Small/fast models preferred for name generation */
-const PREFERRED_MODELS = [getKnownModel("HAIKU").id, getKnownModel("GPT_MINI").id];
-
 /**
- * Build ordered candidate list respecting gateway prefs.
- * Takes primitive/stable values to avoid re-computation on every render.
+ * Build ordered candidate list for name generation.
+ * Gateway routing is resolved automatically by createModel on the backend,
+ * so candidates are sent as canonical model IDs.
  */
-function buildCandidates(
-  isGatewayActive: boolean,
-  modelUsesGateway: (modelId: string) => boolean,
-  userModel: string | undefined
-): string[] {
-  const candidates: string[] = [];
-
-  // 1. Preferred models with gateway prefs applied
-  for (const modelId of PREFERRED_MODELS) {
-    const transformed =
-      isGatewayActive && modelUsesGateway(modelId) ? formatAsGatewayModel(modelId) : modelId;
-    if (!candidates.includes(transformed)) {
-      candidates.push(transformed);
-    }
-  }
-
-  // 2. User's selected model (already gateway-transformed by caller)
+function buildNameGenCandidates(userModel: string | undefined): string[] {
+  const candidates: string[] = [...NAME_GEN_PREFERRED_MODELS];
   if (userModel && !candidates.includes(userModel)) {
     candidates.push(userModel);
   }
-
   return candidates;
 }
 
@@ -147,13 +128,7 @@ export function getDisplayTitleFromPersistedState(state: unknown): string {
 export function useWorkspaceName(options: UseWorkspaceNameOptions): UseWorkspaceNameReturn {
   const { message, debounceMs = 500, userModel, scopeId } = options;
   const { api } = useAPI();
-  const { isActive: isGatewayActive, modelUsesGateway } = useGateway();
-  // Memoize candidates with stable dependencies (isGatewayActive is primitive,
-  // modelUsesGateway is a useCallback that only changes when enabledModels changes)
-  const candidates = useMemo(
-    () => buildCandidates(isGatewayActive, modelUsesGateway, userModel),
-    [isGatewayActive, modelUsesGateway, userModel]
-  );
+  const candidates = useMemo(() => buildNameGenCandidates(userModel), [userModel]);
 
   // Always call usePersistedState, but only *use* it when scopeId is provided.
   // This prevents draft switching from leaking name state across different creation drafts.
@@ -239,7 +214,7 @@ export function useWorkspaceName(options: UseWorkspaceNameOptions): UseWorkspace
       generationPromiseRef.current = { promise, resolve: safeResolve, requestId };
 
       try {
-        // Frontend builds candidate list with gateway prefs applied.
+        // Frontend sends canonical candidates; backend createModel resolves gateway routing.
         // Backend tries candidates in order with retry on API errors.
         const result = await api.nameGeneration.generate({
           message: forMessage,
diff --git a/src/browser/utils/chatCommands.ts b/src/browser/utils/chatCommands.ts
index 7c35d43f57..1826ac5442 100644
--- a/src/browser/utils/chatCommands.ts
+++ b/src/browser/utils/chatCommands.ts
@@ -62,7 +62,7 @@ const BUILT_IN_MODEL_SET = new Set<string>(Object.values(KNOWN_MODELS).map((mode
 export interface ForkOptions {
   client: RouterClient<AppRouter>;
   sourceWorkspaceId: string;
-  newName: string;
+  newName?: string;
   startMessage?: string;
   sendMessageOptions?: SendMessageOptions;
 }
@@ -328,8 +328,6 @@ export async function processSlashCommand(
       case "command-invalid-args":
       case "unknown-command":
         return parsed.command;
-      case "fork-help":
-        return "fork";
       default:
         return null;
     }
@@ -510,7 +508,6 @@ async function handleForkCommand(
     const forkResult = await forkWorkspace({
       client,
       sourceWorkspaceId: workspaceId,
-      newName: parsed.newName,
       startMessage: parsed.startMessage,
       sendMessageOptions,
     });
@@ -527,10 +524,12 @@ async function handleForkCommand(
       return { clearInput: false, toastShown: true };
     } else {
       trackCommandUsed("fork");
+      const displayName =
+        forkResult.workspaceInfo?.title ?? forkResult.workspaceInfo?.name ?? "new workspace";
       setToast({
         id: Date.now().toString(),
         type: "success",
-        message: `Forked to workspace "${parsed.newName}"`,
+        message: `Forked to workspace "${displayName}"`,
       });
       return { clearInput: true, toastShown: true };
     }
diff --git a/src/browser/utils/commandIds.ts b/src/browser/utils/commandIds.ts
index 565acc9eaa..a8c2754d2d 100644
--- a/src/browser/utils/commandIds.ts
+++ b/src/browser/utils/commandIds.ts
@@ -24,8 +24,9 @@ export const CommandIds = {
   workspaceNewInProject: () => "ws:new-in-project" as const,
   workspaceRemove: () => "ws:remove" as const,
   workspaceRemoveAny: () => "ws:remove-any" as const,
-  workspaceRename: () => "ws:rename" as const,
-  workspaceRenameAny: () => "ws:rename-any" as const,
+  workspaceEditTitle: () => "ws:edit-title" as const,
+  workspaceEditTitleAny: () => "ws:edit-title-any" as const,
+  workspaceGenerateTitle: () => "ws:generate-title" as const,
   workspaceOpenTerminal: () => "ws:open-terminal" as const,
   workspaceOpenTerminalCurrent: () => "ws:open-terminal-current" as const,
   workspaceArchiveMergedInProject: () => "ws:archive-merged-in-project" as const,
diff --git a/src/browser/utils/commands/sources.test.ts b/src/browser/utils/commands/sources.test.ts
index 5bd1d2c9a3..af21d92e38 100644
--- a/src/browser/utils/commands/sources.test.ts
+++ b/src/browser/utils/commands/sources.test.ts
@@ -3,6 +3,9 @@ import { buildCoreSources } from "./sources";
 import type { ProjectConfig } from "@/node/config";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import { DEFAULT_RUNTIME_CONFIG } from "@/common/constants/workspace";
+import { GlobalWindow } from "happy-dom";
+import { CUSTOM_EVENTS } from "@/common/constants/events";
+import { MUX_HELP_CHAT_WORKSPACE_ID } from "@/common/constants/muxChat";
 import type { APIClient } from "@/browser/contexts/API";
 
 const mk = (over: Partial<Parameters<typeof buildCoreSources>[0]> = {}) => {
@@ -44,7 +47,7 @@ const mk = (over: Partial<Parameters<typeof buildCoreSources>[0]> = {}) => {
     onArchiveMergedWorkspacesInProject: () => Promise.resolve(),
     onSelectWorkspace: () => undefined,
     onRemoveWorkspace: () => Promise.resolve({ success: true }),
-    onRenameWorkspace: () => Promise.resolve({ success: true }),
+    onUpdateTitle: () => Promise.resolve({ success: true }),
     onAddProject: () => undefined,
     onRemoveProject: () => undefined,
     onToggleSidebar: () => undefined,
@@ -182,3 +185,53 @@ test("archive merged workspaces prompt submits selected project", async () => {
   expect(onArchiveMergedWorkspacesInProject).toHaveBeenCalledTimes(1);
   expect(onArchiveMergedWorkspacesInProject).toHaveBeenCalledWith("/repo/a");
 });
+
+test("workspace generate title command is hidden for Chat with Mux workspace", () => {
+  const sources = mk({
+    selectedWorkspace: {
+      projectPath: "/repo/a",
+      projectName: "a",
+      namedWorkspacePath: "/repo/a/mux-help",
+      workspaceId: MUX_HELP_CHAT_WORKSPACE_ID,
+    },
+  });
+  const actions = sources.flatMap((s) => s());
+
+  expect(actions.some((action) => action.id === "ws:generate-title")).toBe(false);
+});
+
+test("workspace generate title command dispatches a title-generation request event", async () => {
+  const testWindow = new GlobalWindow();
+  const originalWindow = globalThis.window;
+  const originalDocument = globalThis.document;
+  const originalCustomEvent = globalThis.CustomEvent;
+
+  globalThis.window = testWindow as unknown as Window & typeof globalThis;
+  globalThis.document = testWindow.document as unknown as Document;
+  globalThis.CustomEvent = testWindow.CustomEvent as unknown as typeof CustomEvent;
+
+  const receivedWorkspaceIds: string[] = [];
+  const handleRequest = (event: Event) => {
+    const detail = (event as CustomEvent<{ workspaceId: string }>).detail;
+    receivedWorkspaceIds.push(detail.workspaceId);
+  };
+
+  window.addEventListener(CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED, handleRequest);
+
+  try {
+    const sources = mk();
+    const actions = sources.flatMap((s) => s());
+    const generateTitleAction = actions.find((a) => a.id === "ws:generate-title");
+
+    expect(generateTitleAction).toBeDefined();
+
+    await generateTitleAction!.run();
+
+    expect(receivedWorkspaceIds).toEqual(["w1"]);
+  } finally {
+    window.removeEventListener(CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED, handleRequest);
+    globalThis.window = originalWindow;
+    globalThis.document = originalDocument;
+    globalThis.CustomEvent = originalCustomEvent;
+  }
+});
diff --git a/src/browser/utils/commands/sources.ts b/src/browser/utils/commands/sources.ts
index 3db77e077d..65a4fdc617 100644
--- a/src/browser/utils/commands/sources.ts
+++ b/src/browser/utils/commands/sources.ts
@@ -12,6 +12,7 @@ import {
   RIGHT_SIDEBAR_TAB_KEY,
 } from "@/common/constants/storage";
 import { readPersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
+import { MUX_HELP_CHAT_WORKSPACE_ID } from "@/common/constants/muxChat";
 import { disableAutoRetryPreference } from "@/browser/utils/messages/autoRetryPreference";
 import { CommandIds } from "@/browser/utils/commandIds";
 import { isTabType, type TabType } from "@/browser/types/rightSidebar";
@@ -66,7 +67,7 @@ export interface BuildSourcesParams {
     workspaceId: string;
   }) => void;
   onRemoveWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
-  onRenameWorkspace: (
+  onUpdateTitle: (
     workspaceId: string,
     newName: string
   ) => Promise<{ success: boolean; error?: string }>;
@@ -263,30 +264,52 @@ export function buildCoreSources(p: BuildSourcesParams): Array<() => CommandActi
         },
       });
       list.push({
-        id: CommandIds.workspaceRename(),
-        title: "Rename Current Workspace…",
+        id: CommandIds.workspaceEditTitle(),
+        title: "Edit Current Workspace Title…",
         subtitle: workspaceDisplayName,
+        shortcutHint: formatKeybind(KEYBINDS.EDIT_WORKSPACE_TITLE),
         section: section.workspaces,
         run: () => undefined,
         prompt: {
-          title: "Rename Workspace",
+          title: "Edit Workspace Title",
           fields: [
             {
               type: "text",
-              name: "newName",
-              label: "New name",
-              placeholder: "Enter new workspace name",
-              // Use workspace metadata name (not path) for initial value
-              initialValue: p.workspaceMetadata.get(selected.workspaceId)?.name ?? "",
-              getInitialValue: () => p.workspaceMetadata.get(selected.workspaceId)?.name ?? "",
-              validate: (v) => (!v.trim() ? "Name is required" : null),
+              name: "newTitle",
+              label: "New title",
+              placeholder: "Enter new workspace title",
+              initialValue:
+                p.workspaceMetadata.get(selected.workspaceId)?.title ??
+                p.workspaceMetadata.get(selected.workspaceId)?.name ??
+                "",
+              getInitialValue: () => {
+                const current = p.workspaceMetadata.get(selected.workspaceId);
+                return current?.title ?? current?.name ?? "";
+              },
+              validate: (v) => (!v.trim() ? "Title is required" : null),
             },
           ],
           onSubmit: async (vals) => {
-            await p.onRenameWorkspace(selected.workspaceId, vals.newName.trim());
+            await p.onUpdateTitle(selected.workspaceId, vals.newTitle.trim());
           },
         },
       });
+      if (selected.workspaceId !== MUX_HELP_CHAT_WORKSPACE_ID) {
+        list.push({
+          id: CommandIds.workspaceGenerateTitle(),
+          title: "Generate New Title for Current Workspace",
+          subtitle: workspaceDisplayName,
+          shortcutHint: formatKeybind(KEYBINDS.GENERATE_WORKSPACE_TITLE),
+          section: section.workspaces,
+          run: () => {
+            window.dispatchEvent(
+              createCustomEvent(CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED, {
+                workspaceId: selected.workspaceId,
+              })
+            );
+          },
+        });
+      }
     }
 
     if (p.workspaceMetadata.size > 0) {
@@ -328,12 +351,12 @@ export function buildCoreSources(p: BuildSourcesParams): Array<() => CommandActi
         },
       });
       list.push({
-        id: CommandIds.workspaceRenameAny(),
-        title: "Rename Workspace…",
+        id: CommandIds.workspaceEditTitleAny(),
+        title: "Edit Workspace Title…",
         section: section.workspaces,
         run: () => undefined,
         prompt: {
-          title: "Rename Workspace",
+          title: "Edit Workspace Title",
           fields: [
             {
               type: "select",
@@ -358,20 +381,20 @@ export function buildCoreSources(p: BuildSourcesParams): Array<() => CommandActi
             },
             {
               type: "text",
-              name: "newName",
-              label: "New name",
-              placeholder: "Enter new workspace name",
+              name: "newTitle",
+              label: "New title",
+              placeholder: "Enter new workspace title",
               getInitialValue: (values) => {
                 const meta = Array.from(p.workspaceMetadata.values()).find(
                   (m) => m.id === values.workspaceId
                 );
-                return meta ? meta.name : "";
+                return meta?.title ?? meta?.name ?? "";
               },
-              validate: (v) => (!v.trim() ? "Name is required" : null),
+              validate: (v) => (!v.trim() ? "Title is required" : null),
             },
           ],
           onSubmit: async (vals) => {
-            await p.onRenameWorkspace(vals.workspaceId, vals.newName.trim());
+            await p.onUpdateTitle(vals.workspaceId, vals.newTitle.trim());
           },
         },
       });
diff --git a/src/browser/utils/slashCommands/fork.test.ts b/src/browser/utils/slashCommands/fork.test.ts
index c394580793..47e25d909e 100644
--- a/src/browser/utils/slashCommands/fork.test.ts
+++ b/src/browser/utils/slashCommands/fork.test.ts
@@ -1,64 +1,33 @@
 import { parseCommand } from "./parser";
 
 describe("/fork command", () => {
-  it("should parse /fork without arguments to show help", () => {
+  it("should parse /fork without arguments (seamless fork)", () => {
     const result = parseCommand("/fork");
-    expect(result).toEqual({
-      type: "fork-help",
-    });
-  });
-
-  it("should parse /fork with new name", () => {
-    const result = parseCommand("/fork new-workspace");
     expect(result).toEqual({
       type: "fork",
-      newName: "new-workspace",
-      startMessage: undefined,
     });
   });
 
-  it("should parse /fork with name and start message on same line", () => {
-    const result = parseCommand("/fork new-workspace Continue with feature X");
+  it("should parse /fork with start message", () => {
+    const result = parseCommand("/fork Continue with feature X");
     expect(result).toEqual({
       type: "fork",
-      newName: "new-workspace",
       startMessage: "Continue with feature X",
     });
   });
 
-  it("should parse /fork with name and multiline start message", () => {
-    const result = parseCommand("/fork new-workspace\nContinue with feature X");
-    expect(result).toEqual({
-      type: "fork",
-      newName: "new-workspace",
-      startMessage: "Continue with feature X",
-    });
-  });
-
-  it("should prefer multiline content over same-line tokens", () => {
-    const result = parseCommand("/fork new-workspace same line\nMultiline content");
-    expect(result).toEqual({
-      type: "fork",
-      newName: "new-workspace",
-      startMessage: "Multiline content",
-    });
-  });
-
-  it("should handle quoted workspace names", () => {
-    const result = parseCommand('/fork "my workspace"');
+  it("should treat all text after /fork as start message", () => {
+    const result = parseCommand("/fork new-workspace same line content");
     expect(result).toEqual({
       type: "fork",
-      newName: "my workspace",
-      startMessage: undefined,
+      startMessage: "new-workspace same line content",
     });
   });
 
-  it("should handle multiline messages with multiple lines", () => {
-    const result = parseCommand("/fork new-workspace\nLine 1\nLine 2\nLine 3");
+  it("should handle /fork with trailing whitespace", () => {
+    const result = parseCommand("/fork   ");
     expect(result).toEqual({
       type: "fork",
-      newName: "new-workspace",
-      startMessage: "Line 1\nLine 2\nLine 3",
     });
   });
 });
diff --git a/src/browser/utils/slashCommands/parser.test.ts b/src/browser/utils/slashCommands/parser.test.ts
index e37ef9c99b..5db163d8f7 100644
--- a/src/browser/utils/slashCommands/parser.test.ts
+++ b/src/browser/utils/slashCommands/parser.test.ts
@@ -143,25 +143,16 @@ describe("commandParser", () => {
       });
     });
 
-    it("should parse /fork command with name only", () => {
-      expectParse("/fork feature-branch", {
-        type: "fork",
-        newName: "feature-branch",
-        startMessage: undefined,
-      });
+    it("should parse /fork with no args (seamless fork)", () => {
+      expectParse("/fork", { type: "fork" });
     });
 
-    it("should parse /fork command with start message", () => {
-      expectParse("/fork feature-branch let's go", {
+    it("should parse /fork with start message", () => {
+      expectParse("/fork let's explore this idea", {
         type: "fork",
-        newName: "feature-branch",
-        startMessage: "let's go",
+        startMessage: "let's explore this idea",
       });
     });
-
-    it("should show /fork help when missing args", () => {
-      expectParse("/fork", { type: "fork-help" });
-    });
   });
 });
 
diff --git a/src/browser/utils/slashCommands/registry.ts b/src/browser/utils/slashCommands/registry.ts
index acf1475400..3b9b458026 100644
--- a/src/browser/utils/slashCommands/registry.ts
+++ b/src/browser/utils/slashCommands/registry.ts
@@ -13,8 +13,8 @@ import { MODEL_ABBREVIATIONS } from "@/common/constants/knownModels";
 import { normalizeModelInput } from "@/browser/utils/models/normalizeModelInput";
 
 /**
- * Parse multiline command input into first-line tokens and remaining message
- * Used by commands that support messages on subsequent lines (/compact, /fork, /new)
+ * Parse multiline command input into first-line tokens and remaining message.
+ * Used by commands that support messages on subsequent lines (/compact, /new).
  */
 function parseMultilineCommand(rawInput: string): {
   firstLine: string;
@@ -286,33 +286,18 @@ const planCommandDefinition: SlashCommandDefinition = {
 
 const forkCommandDefinition: SlashCommandDefinition = {
   key: "fork",
-  description:
-    "Fork workspace with new name and optional start message. Add start message on lines after the command.",
+  description: "Fork workspace. Optionally include a start message.",
   handler: ({ rawInput }): ParsedCommand => {
-    const { tokens, message } = parseMultilineCommand(rawInput);
-
-    if (tokens.length === 0) {
-      return {
-        type: "fork-help",
-      };
-    }
-
-    const newName = tokens[0];
-
-    // Start message can be from remaining tokens on same line or multiline content
-    let startMessage: string | undefined;
-    if (message) {
-      // Multiline content takes precedence
-      startMessage = message;
-    } else if (tokens.length > 1) {
-      // Join remaining tokens on first line
-      startMessage = tokens.slice(1).join(" ").trim();
+    const trimmed = rawInput.trim();
+    if (trimmed.length === 0) {
+      // No args → immediate fork with auto-generated name, no start message
+      return { type: "fork" };
     }
 
+    // Everything after /fork is the start message (name is auto-generated by backend)
     return {
       type: "fork",
-      newName,
-      startMessage: startMessage && startMessage.length > 0 ? startMessage : undefined,
+      startMessage: trimmed,
     };
   },
 };
diff --git a/src/browser/utils/slashCommands/types.ts b/src/browser/utils/slashCommands/types.ts
index cc2b43819b..c3ea03d81f 100644
--- a/src/browser/utils/slashCommands/types.ts
+++ b/src/browser/utils/slashCommands/types.ts
@@ -26,8 +26,7 @@ export type ParsedCommand =
   | { type: "clear" }
   | { type: "truncate"; percentage: number }
   | { type: "compact"; maxOutputTokens?: number; continueMessage?: string; model?: string }
-  | { type: "fork"; newName: string; startMessage?: string }
-  | { type: "fork-help" }
+  | { type: "fork"; startMessage?: string }
   | {
       type: "new";
       workspaceName?: string;
diff --git a/src/browser/utils/ui/keybinds.ts b/src/browser/utils/ui/keybinds.ts
index e1ef7c28ff..bfd71c8418 100644
--- a/src/browser/utils/ui/keybinds.ts
+++ b/src/browser/utils/ui/keybinds.ts
@@ -273,6 +273,12 @@ export const KEYBINDS = {
   /** Create new workspace for current project */
   NEW_WORKSPACE: { key: "n", ctrl: true },
 
+  /** Edit title of current workspace (inline edit) */
+  EDIT_WORKSPACE_TITLE: { key: "F2" },
+
+  /** Generate new title for current workspace via AI */
+  GENERATE_WORKSPACE_TITLE: { key: "F2", shift: true },
+
   /** Archive current workspace */
   // macOS: Cmd+Shift+Backspace, Win/Linux: Ctrl+Shift+Backspace
   ARCHIVE_WORKSPACE: { key: "Backspace", ctrl: true, shift: true, macCtrlBehavior: "command" },
diff --git a/src/common/constants/events.ts b/src/common/constants/events.ts
index d14f05c7c5..63510bf756 100644
--- a/src/common/constants/events.ts
+++ b/src/common/constants/events.ts
@@ -71,6 +71,12 @@ export const CUSTOM_EVENTS = {
    */
   WORKSPACE_FORK_SWITCH: "mux:workspaceForkSwitch",
 
+  /**
+   * Event to request AI title regeneration for a workspace.
+   * Detail: { workspaceId: string }
+   */
+  WORKSPACE_GENERATE_TITLE_REQUESTED: "mux:workspaceGenerateTitleRequested",
+
   /**
    * Event to execute a command from the command palette
    * Detail: { commandId: string }
@@ -126,6 +132,9 @@ export interface CustomEventPayloads {
     workspacePath: string;
     branch: string;
   };
+  [CUSTOM_EVENTS.WORKSPACE_GENERATE_TITLE_REQUESTED]: {
+    workspaceId: string;
+  };
   [CUSTOM_EVENTS.EXECUTE_COMMAND]: {
     commandId: string;
   };
diff --git a/src/common/constants/nameGeneration.ts b/src/common/constants/nameGeneration.ts
new file mode 100644
index 0000000000..02264d0f20
--- /dev/null
+++ b/src/common/constants/nameGeneration.ts
@@ -0,0 +1,4 @@
+import { getKnownModel } from "@/common/constants/knownModels";
+
+/** Small/fast models preferred for AI-generated workspace names and titles. */
+export const NAME_GEN_PREFERRED_MODELS = [getKnownModel("HAIKU").id, getKnownModel("GPT_MINI").id];
diff --git a/src/common/orpc/schemas/api.ts b/src/common/orpc/schemas/api.ts
index 5a16530074..d36a0137fc 100644
--- a/src/common/orpc/schemas/api.ts
+++ b/src/common/orpc/schemas/api.ts
@@ -820,6 +820,10 @@ export const workspace = {
     input: z.object({ workspaceId: z.string(), title: z.string() }),
     output: ResultSchema(z.void(), z.string()),
   },
+  regenerateTitle: {
+    input: z.object({ workspaceId: z.string() }),
+    output: ResultSchema(z.object({ title: z.string() }), z.string()),
+  },
   updateAgentAISettings: {
     input: z.object({
       workspaceId: z.string(),
@@ -861,7 +865,7 @@ export const workspace = {
     ),
   },
   fork: {
-    input: z.object({ sourceWorkspaceId: z.string(), newName: z.string() }),
+    input: z.object({ sourceWorkspaceId: z.string(), newName: z.string().optional() }),
     output: z.discriminatedUnion("success", [
       z.object({
         success: z.literal(true),
@@ -1254,7 +1258,7 @@ export const nameGeneration = {
   generate: {
     input: z.object({
       message: z.string(),
-      /** Ordered list of model candidates to try (frontend applies gateway prefs) */
+      /** Ordered list of model candidates to try (backend resolves gateway routing in createModel) */
       candidates: z.array(z.string()),
     }),
     output: ResultSchema(
diff --git a/src/node/orpc/router.ts b/src/node/orpc/router.ts
index 928bae44ba..a14984f887 100644
--- a/src/node/orpc/router.ts
+++ b/src/node/orpc/router.ts
@@ -2314,7 +2314,7 @@ export const router = (authToken?: string) => {
         .input(schemas.nameGeneration.generate.input)
         .output(schemas.nameGeneration.generate.output)
         .handler(async ({ context, input }) => {
-          // Frontend provides ordered candidate list with gateway prefs applied.
+          // Frontend provides ordered candidate list; gateway routing resolved by createModel.
           // Backend tries candidates in order with retry on API errors.
           const result = await generateWorkspaceIdentity(
             input.message,
@@ -2435,6 +2435,12 @@ export const router = (authToken?: string) => {
         .handler(async ({ context, input }) => {
           return context.workspaceService.updateTitle(input.workspaceId, input.title);
         }),
+      regenerateTitle: t
+        .input(schemas.workspace.regenerateTitle.input)
+        .output(schemas.workspace.regenerateTitle.output)
+        .handler(async ({ context, input }) => {
+          return context.workspaceService.regenerateTitle(input.workspaceId);
+        }),
       archive: t
         .input(schemas.workspace.archive.input)
         .output(schemas.workspace.archive.output)
diff --git a/src/node/services/aiService.ts b/src/node/services/aiService.ts
index 026b899313..ff18b8f0b9 100644
--- a/src/node/services/aiService.ts
+++ b/src/node/services/aiService.ts
@@ -923,8 +923,6 @@ export class AIService extends EventEmitter {
               runtimeTempDir,
               runtime,
               agentDiscoveryPath,
-              resolveGatewayModelString: (ms, dm, eg) =>
-                this.providerModelFactory.resolveGatewayModelString(ms, dm, eg),
               createModel: (ms, o) => this.createModel(ms, o),
               emitBashOutput: (ev) => this.emit("bash-output", ev),
               sessionUsageService: this.sessionUsageService,
diff --git a/src/node/services/providerModelFactory.test.ts b/src/node/services/providerModelFactory.test.ts
index 0f493263e0..77bc4ebd91 100644
--- a/src/node/services/providerModelFactory.test.ts
+++ b/src/node/services/providerModelFactory.test.ts
@@ -58,6 +58,32 @@ describe("ProviderModelFactory.createModel", () => {
       }
     });
   });
+
+  it("routes allowlisted models through gateway automatically", async () => {
+    await withTempConfig(async (config, factory) => {
+      config.saveProvidersConfig({
+        openai: {
+          apiKey: "sk-test",
+          enabled: false,
+        },
+        "mux-gateway": {
+          couponCode: "test-coupon",
+        },
+      });
+
+      const projectConfig = config.loadConfigOrDefault();
+      await config.saveConfig({
+        ...projectConfig,
+        muxGatewayEnabled: true,
+        muxGatewayModels: ["openai:gpt-5"],
+      });
+
+      const result = await factory.createModel("openai:gpt-5");
+      if (!result.success) {
+        expect(result.error.type).not.toBe("provider_disabled");
+      }
+    });
+  });
 });
 
 describe("ProviderModelFactory.resolveGatewayModelString", () => {
diff --git a/src/node/services/providerModelFactory.ts b/src/node/services/providerModelFactory.ts
index 11e07f8ad4..1a3bc58c37 100644
--- a/src/node/services/providerModelFactory.ts
+++ b/src/node/services/providerModelFactory.ts
@@ -397,8 +397,17 @@ export class ProviderModelFactory {
     muxProviderOptions?: MuxProviderOptions
   ): Promise<Result<LanguageModel, SendMessageError>> {
     try {
+      // Gateway routing is resolved here so every caller gets correct behavior
+      // automatically. resolveGatewayModelString is idempotent — already-resolved
+      // strings (e.g. "mux-gateway:anthropic/model") pass through unchanged.
+      const explicitlyRequestedGateway = modelString.trim().startsWith("mux-gateway:");
+      modelString = this.resolveGatewayModelString(
+        modelString,
+        undefined,
+        explicitlyRequestedGateway
+      );
+
       // Parse model string (format: "provider:model-id")
-      // Parse provider and model ID from model string
       const [providerName, modelId] = parseModelString(modelString);
 
       if (!providerName || !modelId) {
diff --git a/src/node/services/system1ToolWrapper.ts b/src/node/services/system1ToolWrapper.ts
index 2b3368c13a..745d155553 100644
--- a/src/node/services/system1ToolWrapper.ts
+++ b/src/node/services/system1ToolWrapper.ts
@@ -61,11 +61,6 @@ export interface System1WrapOptions {
   runtime: Runtime;
   agentDiscoveryPath: string;
   /** Callbacks to break the dependency on AIService / StreamManager. */
-  resolveGatewayModelString: (
-    modelString: string,
-    defaultModel?: string,
-    explicitGateway?: boolean
-  ) => string;
   createModel: (
     modelString: string,
     opts?: MuxProviderOptions
@@ -105,12 +100,8 @@ export function wrapToolsWithSystem1(opts: System1WrapOptions): Record<string, T
     if (cachedSystem1Model) return cachedSystem1Model;
     if (cachedSystem1ModelFailed) return undefined;
 
-    const resolvedModelString = opts.resolveGatewayModelString(
-      system1Ctx.modelString,
-      undefined,
-      system1Ctx.explicitGateway
-    );
-    const created = await opts.createModel(resolvedModelString, opts.muxProviderOptions);
+    // createModel handles gateway routing automatically — pass the raw string.
+    const created = await opts.createModel(system1Ctx.modelString, opts.muxProviderOptions);
     if (!created.success) {
       cachedSystem1ModelFailed = true;
       log.debug("[system1] Failed to create System 1 model", {
@@ -121,7 +112,7 @@ export function wrapToolsWithSystem1(opts: System1WrapOptions): Record<string, T
       return undefined;
     }
 
-    cachedSystem1Model = { modelString: resolvedModelString, model: created.data };
+    cachedSystem1Model = { modelString: system1Ctx.modelString, model: created.data };
     return cachedSystem1Model;
   };
 
@@ -184,21 +175,22 @@ function getExecuteFn(tool: Tool | undefined): ExecuteFn | undefined {
 }
 
 interface System1ModelContext {
+  /** Raw model string (may include mux-gateway: prefix). Passed to createModel which resolves gateway routing internally. */
   modelString: string;
-  explicitGateway: boolean;
   thinkingLevel: ThinkingLevel;
 }
 
 function buildSystem1ModelContext(opts: System1WrapOptions): System1ModelContext {
   const raw = typeof opts.system1Model === "string" ? opts.system1Model.trim() : "";
-  const modelString = raw ? normalizeGatewayModel(raw) : "";
-  const explicitGateway = raw.startsWith("mux-gateway:");
-  const effectiveModelForThinking = modelString || opts.modelString;
+  // Canonical form (gateway prefix stripped) for provider checks like thinking level.
+  const canonical = raw ? normalizeGatewayModel(raw) : "";
+  const effectiveModelForThinking = canonical || opts.modelString;
   const thinkingLevel = enforceThinkingPolicy(
     effectiveModelForThinking,
     opts.system1ThinkingLevel ?? "off"
   );
-  return { modelString, explicitGateway, thinkingLevel };
+  // Store the raw string so createModel can detect explicit mux-gateway: prefix.
+  return { modelString: raw, thinkingLevel };
 }
 
 // ---------------------------------------------------------------------------
diff --git a/src/node/services/workspaceService.test.ts b/src/node/services/workspaceService.test.ts
index 915af30b6b..b2b71c8fdc 100644
--- a/src/node/services/workspaceService.test.ts
+++ b/src/node/services/workspaceService.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import { WorkspaceService } from "./workspaceService";
+import { WorkspaceService, generateForkBranchName, generateForkTitle } from "./workspaceService";
 import type { AgentSession } from "./agentSession";
 import { WorkspaceLifecycleHooks } from "./workspaceLifecycleHooks";
 import { EventEmitter } from "events";
@@ -18,8 +18,10 @@ import type { ExtensionMetadataService } from "./ExtensionMetadataService";
 import type { FrontendWorkspaceMetadata, WorkspaceMetadata } from "@/common/types/workspace";
 import type { BackgroundProcessManager } from "./backgroundProcessManager";
 import type { BashToolResult } from "@/common/types/tools";
+import { createMuxMessage } from "@/common/types/message";
 import { MUX_HELP_CHAT_WORKSPACE_ID } from "@/common/constants/muxChat";
 import * as runtimeFactory from "@/node/runtime/runtimeFactory";
+import * as workspaceTitleGenerator from "./workspaceTitleGenerator";
 
 // Helper to access private renamingWorkspaces set
 function addToRenamingWorkspaces(service: WorkspaceService, workspaceId: string): void {
@@ -1881,3 +1883,264 @@ describe("WorkspaceService init cancellation", () => {
     }
   });
 });
+
+describe("WorkspaceService regenerateTitle", () => {
+  let workspaceService: WorkspaceService;
+  let historyService: HistoryService;
+  let cleanupHistory: () => Promise<void>;
+
+  beforeEach(async () => {
+    const mockAIService = {
+      isStreaming: mock(() => false),
+      getWorkspaceMetadata: mock(() =>
+        Promise.resolve({ success: false as const, error: "workspace metadata unavailable" })
+      ),
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      on: mock(() => {}),
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      off: mock(() => {}),
+    } as unknown as AIService;
+
+    ({ historyService, cleanup: cleanupHistory } = await createTestHistoryService());
+
+    const mockConfig: Partial<Config> = {
+      srcDir: "/tmp/test",
+      getSessionDir: mock(() => "/tmp/test/sessions"),
+      generateStableId: mock(() => "test-id"),
+      findWorkspace: mock(() => ({ projectPath: "/tmp/proj", workspacePath: "/tmp/proj/ws" })),
+    };
+    const mockInitStateManager: Partial<InitStateManager> = {
+      on: mock(() => undefined as unknown as InitStateManager),
+      getInitState: mock(() => undefined),
+    };
+
+    workspaceService = new WorkspaceService(
+      mockConfig as Config,
+      historyService,
+      mockAIService,
+      mockInitStateManager as InitStateManager,
+      mockExtensionMetadataService as ExtensionMetadataService,
+      mockBackgroundProcessManager as BackgroundProcessManager
+    );
+  });
+
+  afterEach(async () => {
+    await cleanupHistory();
+  });
+
+  test("returns updateTitle error when persisting generated title fails", async () => {
+    const workspaceId = "ws-regenerate-title";
+
+    await historyService.appendToHistory(workspaceId, createMuxMessage("user-1", "user", "Fix CI"));
+
+    const generateIdentitySpy = spyOn(
+      workspaceTitleGenerator,
+      "generateWorkspaceIdentity"
+    ).mockResolvedValue(
+      Ok({
+        name: "ci-fix-a1b2",
+        title: "Fix CI",
+        modelUsed: "anthropic:claude-3-5-haiku-latest",
+      })
+    );
+    const updateTitleSpy = spyOn(workspaceService, "updateTitle").mockResolvedValueOnce(
+      Err("Failed to update workspace title: disk full")
+    );
+
+    try {
+      const result = await workspaceService.regenerateTitle(workspaceId);
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBe("Failed to update workspace title: disk full");
+      }
+      expect(updateTitleSpy).toHaveBeenCalledWith(workspaceId, "Fix CI");
+    } finally {
+      updateTitleSpy.mockRestore();
+      generateIdentitySpy.mockRestore();
+    }
+  });
+  test("falls back to full history when latest compaction epoch has no user message", async () => {
+    const workspaceId = "ws-regenerate-title-compacted";
+
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("user-before-boundary", "user", "Refactor sidebar loading")
+    );
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("summary-boundary", "assistant", "Compacted summary", {
+        compacted: true,
+        compactionBoundary: true,
+        compactionEpoch: 1,
+      })
+    );
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("assistant-after-boundary", "assistant", "No new user messages yet")
+    );
+
+    const iterateSpy = spyOn(historyService, "iterateFullHistory");
+    const generateIdentitySpy = spyOn(
+      workspaceTitleGenerator,
+      "generateWorkspaceIdentity"
+    ).mockResolvedValue(
+      Ok({
+        name: "sidebar-refactor-a1b2",
+        title: "Refactor sidebar loading",
+        modelUsed: "anthropic:claude-3-5-haiku-latest",
+      })
+    );
+    const updateTitleSpy = spyOn(workspaceService, "updateTitle").mockResolvedValueOnce(
+      Ok(undefined)
+    );
+
+    try {
+      const result = await workspaceService.regenerateTitle(workspaceId);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.title).toBe("Refactor sidebar loading");
+      }
+      expect(iterateSpy).toHaveBeenCalledTimes(1);
+      expect(generateIdentitySpy).toHaveBeenCalledWith(
+        "Refactor sidebar loading",
+        expect.any(Array),
+        expect.anything(),
+        "Compacted summary"
+      );
+      expect(updateTitleSpy).toHaveBeenCalledWith(workspaceId, "Refactor sidebar loading");
+    } finally {
+      updateTitleSpy.mockRestore();
+      generateIdentitySpy.mockRestore();
+      iterateSpy.mockRestore();
+    }
+  });
+  test("uses the first assistant reply after the first user message for context", async () => {
+    const workspaceId = "ws-regenerate-title-assistant-order";
+
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("assistant-summary", "assistant", "Older compacted summary")
+    );
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("user-first", "user", "Refine workspace title generation")
+    );
+    await historyService.appendToHistory(
+      workspaceId,
+      createMuxMessage("assistant-after-user", "assistant", "Useful assistant context")
+    );
+
+    const generateIdentitySpy = spyOn(
+      workspaceTitleGenerator,
+      "generateWorkspaceIdentity"
+    ).mockResolvedValue(
+      Ok({
+        name: "title-refresh-a1b2",
+        title: "Refine workspace title generation",
+        modelUsed: "anthropic:claude-3-5-haiku-latest",
+      })
+    );
+    const updateTitleSpy = spyOn(workspaceService, "updateTitle").mockResolvedValueOnce(
+      Ok(undefined)
+    );
+
+    try {
+      const result = await workspaceService.regenerateTitle(workspaceId);
+
+      expect(result.success).toBe(true);
+      expect(generateIdentitySpy).toHaveBeenCalledWith(
+        "Refine workspace title generation",
+        expect.any(Array),
+        expect.anything(),
+        "Useful assistant context"
+      );
+      expect(updateTitleSpy).toHaveBeenCalledWith(workspaceId, "Refine workspace title generation");
+    } finally {
+      updateTitleSpy.mockRestore();
+      generateIdentitySpy.mockRestore();
+    }
+  });
+});
+
+// --- Pure helper tests (no mocks needed) ---
+
+describe("generateForkBranchName", () => {
+  test("returns -fork-1 when no existing forks", () => {
+    expect(generateForkBranchName("sidebar-a1b2", [])).toBe("sidebar-a1b2-fork-1");
+  });
+
+  test("increments past the highest existing fork number", () => {
+    expect(
+      generateForkBranchName("sidebar-a1b2", [
+        "sidebar-a1b2-fork-1",
+        "sidebar-a1b2-fork-3",
+        "other-workspace",
+      ])
+    ).toBe("sidebar-a1b2-fork-4");
+  });
+
+  test("ignores non-matching workspace names", () => {
+    expect(
+      generateForkBranchName("feature", ["feature-branch", "feature-impl", "other-fork-1"])
+    ).toBe("feature-fork-1");
+  });
+
+  test("handles gaps in numbering", () => {
+    expect(generateForkBranchName("ws", ["ws-fork-1", "ws-fork-5"])).toBe("ws-fork-6");
+  });
+
+  test("treats stale branch names as collisions when choosing next fork name", () => {
+    expect(generateForkBranchName("ws", ["ws-fork-1", "ws-fork-2"])).toBe("ws-fork-3");
+  });
+
+  test("ignores non-numeric suffixes", () => {
+    expect(generateForkBranchName("ws", ["ws-fork-abc", "ws-fork-"])).toBe("ws-fork-1");
+  });
+
+  test("ignores partially numeric suffixes", () => {
+    expect(generateForkBranchName("ws", ["ws-fork-1abc", "ws-fork-02x", "ws-fork-3"])).toBe(
+      "ws-fork-4"
+    );
+  });
+});
+
+describe("generateForkTitle", () => {
+  test("returns (1) when no existing forks", () => {
+    expect(generateForkTitle("Fix sidebar layout", [])).toBe("Fix sidebar layout (1)");
+  });
+
+  test("increments past the highest existing suffix", () => {
+    expect(
+      generateForkTitle("Fix sidebar layout", [
+        "Fix sidebar layout",
+        "Fix sidebar layout (1)",
+        "Fix sidebar layout (3)",
+      ])
+    ).toBe("Fix sidebar layout (4)");
+  });
+
+  test("strips existing suffix from parent before computing base", () => {
+    // Forking "Fix sidebar (2)" should produce "Fix sidebar (3)", not "Fix sidebar (2) (1)"
+    expect(generateForkTitle("Fix sidebar (2)", ["Fix sidebar (1)", "Fix sidebar (2)"])).toBe(
+      "Fix sidebar (3)"
+    );
+  });
+
+  test("ignores non-matching titles", () => {
+    expect(generateForkTitle("Refactor auth", ["Fix sidebar layout (1)", "Other task (2)"])).toBe(
+      "Refactor auth (1)"
+    );
+  });
+
+  test("handles gaps in numbering", () => {
+    expect(generateForkTitle("Task", ["Task (1)", "Task (5)"])).toBe("Task (6)");
+  });
+
+  test("ignores non-numeric suffixes when selecting the next title number", () => {
+    expect(generateForkTitle("Task", ["Task (2025 roadmap)", "Task (12abc)", "Task (2)"])).toBe(
+      "Task (3)"
+    );
+  });
+});
diff --git a/src/node/services/workspaceService.ts b/src/node/services/workspaceService.ts
index 6f6561b83c..7a098a5e74 100644
--- a/src/node/services/workspaceService.ts
+++ b/src/node/services/workspaceService.ts
@@ -28,10 +28,13 @@ import {
 import { createRuntimeForWorkspace } from "@/node/runtime/runtimeHelpers";
 import { validateWorkspaceName } from "@/common/utils/validation/workspaceValidation";
 import { getPlanFilePath, getLegacyPlanFilePath } from "@/common/utils/planStorage";
+import { listLocalBranches } from "@/node/git";
 import { shellQuote } from "@/node/runtime/backgroundCommands";
 import { extractEditedFilePaths } from "@/common/utils/messages/extractEditedFiles";
 import { fileExists } from "@/node/utils/runtime/fileExists";
 import { applyForkRuntimeUpdates } from "@/node/services/utils/forkRuntimeUpdates";
+import { generateWorkspaceIdentity } from "@/node/services/workspaceTitleGenerator";
+import { NAME_GEN_PREFERRED_MODELS } from "@/common/constants/nameGeneration";
 import type { DevcontainerRuntime } from "@/node/runtime/DevcontainerRuntime";
 import { getDevcontainerContainerName } from "@/node/runtime/devcontainerCli";
 import { expandTilde, expandTildeForSSH } from "@/node/runtime/tildeExpansion";
@@ -145,10 +148,76 @@ function appendCollisionSuffix(baseName: string): string {
   return `${baseName}-${suffix}`;
 }
 
+/**
+ * Generate a unique fork branch name from the parent workspace name.
+ * Scans existing workspace names for the `{parentName}-fork-N` pattern
+ * and picks N+1, guaranteeing a valid git-safe branch name.
+ */
+export function generateForkBranchName(parentName: string, existingNames: string[]): string {
+  const prefix = `${parentName}-fork-`;
+  let max = 0;
+  for (const name of existingNames) {
+    if (!name.startsWith(prefix)) {
+      continue;
+    }
+
+    const suffix = name.slice(prefix.length);
+    if (!/^\d+$/.test(suffix)) {
+      continue;
+    }
+
+    const n = Number(suffix);
+    if (n > max) {
+      max = n;
+    }
+  }
+  return `${prefix}${max + 1}`;
+}
+
+/**
+ * Generate a forked workspace title by appending a " (N)" suffix to the parent title.
+ * Scans existing titles in the same project to pick the next available number.
+ */
+export function generateForkTitle(parentTitle: string, existingTitles: string[]): string {
+  // Strip any existing " (N)" suffix from the parent title to get the base
+  const base = parentTitle.replace(/ \(\d+\)$/, "");
+  const prefix = `${base} (`;
+
+  let max = 0;
+  for (const title of existingTitles) {
+    if (!title.startsWith(prefix) || !title.endsWith(")")) {
+      continue;
+    }
+
+    const suffix = title.slice(prefix.length, -1);
+    if (!/^\d+$/.test(suffix)) {
+      continue;
+    }
+
+    const n = Number(suffix);
+    if (n > max) {
+      max = n;
+    }
+  }
+  // If parent title itself exists in the list (without suffix), start at (1)
+  // Otherwise continue from the highest found suffix
+  return `${base} (${max + 1})`;
+}
+
 function isErrnoWithCode(error: unknown, code: string): boolean {
   return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
 }
 
+async function copyIfExists(sourcePath: string, destinationPath: string): Promise<void> {
+  try {
+    await fsPromises.copyFile(sourcePath, destinationPath);
+  } catch (error) {
+    if (!isErrnoWithCode(error, "ENOENT")) {
+      throw error;
+    }
+  }
+}
+
 function isPathInsideDir(dirPath: string, filePath: string): boolean {
   const resolvedDir = path.resolve(dirPath);
   const resolvedFile = path.resolve(filePath);
@@ -1986,6 +2055,115 @@ export class WorkspaceService extends EventEmitter {
     }
   }
 
+  /**
+   * Regenerate the workspace title from its chat history using AI.
+   * Reads the first user message (and optional first assistant reply) as context,
+   * then calls generateWorkspaceIdentity and persists the result via updateTitle.
+   */
+  async regenerateTitle(workspaceId: string): Promise<Result<{ title: string }>> {
+    const historyResult = await this.historyService.getHistoryFromLatestBoundary(workspaceId);
+    if (!historyResult.success) {
+      return Err("Could not read workspace history");
+    }
+
+    const firstUserIndex = historyResult.data.findIndex((m) => m.role === "user");
+    let firstUserMsg = firstUserIndex >= 0 ? historyResult.data[firstUserIndex] : undefined;
+    let firstAssistantMsg =
+      firstUserIndex >= 0
+        ? historyResult.data.slice(firstUserIndex + 1).find((m) => m.role === "assistant")
+        : undefined;
+
+    if (!firstUserMsg) {
+      // Compaction boundaries can leave the latest epoch with only an assistant summary.
+      // Fall back to scanning full history so regenerateTitle still works for compacted chats.
+      let fallbackFirstUser: MuxMessage | undefined;
+      let fallbackFirstAssistant: MuxMessage | undefined;
+      const fullHistoryResult = await this.historyService.iterateFullHistory(
+        workspaceId,
+        "forward",
+        (messages) => {
+          for (const message of messages) {
+            if (!fallbackFirstUser && message.role === "user") {
+              fallbackFirstUser = message;
+              continue;
+            }
+            if (fallbackFirstUser && !fallbackFirstAssistant && message.role === "assistant") {
+              fallbackFirstAssistant = message;
+            }
+          }
+
+          // Stop scanning once we have both context messages.
+          if (fallbackFirstUser && fallbackFirstAssistant) {
+            return false;
+          }
+        }
+      );
+      if (!fullHistoryResult.success) {
+        return Err("Could not read workspace history");
+      }
+
+      firstUserMsg = fallbackFirstUser;
+      firstAssistantMsg ??= fallbackFirstAssistant;
+    }
+
+    if (!firstUserMsg) {
+      return Err("No user messages in workspace history");
+    }
+
+    const userText =
+      firstUserMsg.parts
+        ?.filter((p) => p.type === "text")
+        .map((p) => p.text)
+        .join("\n") || "";
+
+    if (!userText) {
+      return Err("First user message has no text content");
+    }
+
+    // Use the first assistant reply for richer context
+    let assistantContext: string | undefined;
+    if (firstAssistantMsg) {
+      assistantContext =
+        firstAssistantMsg.parts
+          ?.filter((p) => p.type === "text")
+          .map((p) => p.text)
+          .join("\n") ?? undefined;
+    }
+
+    const candidates: string[] = [...NAME_GEN_PREFERRED_MODELS];
+    const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
+    if (metadataResult.success) {
+      const fallbackModels = [
+        metadataResult.data.aiSettings?.model,
+        ...Object.values(metadataResult.data.aiSettingsByAgent ?? {}).map(
+          (settings) => settings.model
+        ),
+      ];
+      for (const model of fallbackModels) {
+        if (model && !candidates.includes(model)) {
+          candidates.push(model);
+        }
+      }
+    }
+
+    const result = await generateWorkspaceIdentity(
+      userText,
+      candidates,
+      this.aiService,
+      assistantContext
+    );
+    if (!result.success) {
+      return Err("Title generation failed");
+    }
+
+    const updateTitleResult = await this.updateTitle(workspaceId, result.data.title);
+    if (!updateTitleResult.success) {
+      return Err(updateTitleResult.error);
+    }
+
+    return Ok({ title: result.data.title });
+  }
+
   /**
    * Archive a workspace. Archived workspaces are hidden from the main sidebar
    * but can be viewed on the project page.
@@ -2521,18 +2699,13 @@ export class WorkspaceService extends EventEmitter {
 
   async fork(
     sourceWorkspaceId: string,
-    newName: string
+    newName?: string
   ): Promise<Result<{ metadata: FrontendWorkspaceMetadata; projectPath: string }>> {
     try {
       if (sourceWorkspaceId === MUX_HELP_CHAT_WORKSPACE_ID) {
         return Err("Cannot fork the Chat with Mux system workspace");
       }
 
-      const validation = validateWorkspaceName(newName);
-      if (!validation.valid) {
-        return Err(validation.error ?? "Invalid workspace name");
-      }
-
       if (this.aiService.isStreaming(sourceWorkspaceId)) {
         await this.historyService.commitPartial(sourceWorkspaceId);
       }
@@ -2559,6 +2732,68 @@ export class WorkspaceService extends EventEmitter {
         return Err("Forking Docker workspaces is not supported. Create a new workspace instead.");
       }
 
+      // Auto-generate branch name (and title) when user omits one (seamless fork).
+      // Uses pattern: {parentName}-fork-{N} for branch, "{parentTitle} (N)" for title.
+      const isAutoName = newName == null;
+      // Fetch all metadata upfront for both branch name and title collision checks.
+      const allMetadata = isAutoName ? await this.config.getAllWorkspaceMetadata() : [];
+      let resolvedName: string;
+      if (isAutoName) {
+        const existingNamesSet = new Set(
+          allMetadata.filter((m) => m.projectPath === foundProjectPath).map((m) => m.name)
+        );
+        // Also include local branch names to avoid silently reusing stale branches that
+        // were left behind on disk but no longer exist in config metadata.
+        try {
+          for (const branchName of await listLocalBranches(foundProjectPath)) {
+            existingNamesSet.add(branchName);
+          }
+        } catch (error) {
+          log.debug("Failed to list local branches for fork auto-name preflight", {
+            projectPath: foundProjectPath,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+
+        const existingNames = [...existingNamesSet];
+        resolvedName = generateForkBranchName(sourceMetadata.name, existingNames);
+
+        if (!validateWorkspaceName(resolvedName).valid) {
+          // Legacy workspace names can violate current naming rules (invalid
+          // chars / length). Normalize and shrink the parent base until the
+          // generated fork name satisfies current invariants.
+          let normalizedParent = sourceMetadata.name
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]+/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^[-_]+|[-_]+$/g, "");
+
+          if (!normalizedParent) {
+            normalizedParent = "workspace";
+          }
+
+          let candidateParent = normalizedParent;
+          while (candidateParent.length > 1) {
+            resolvedName = generateForkBranchName(candidateParent, existingNames);
+            if (validateWorkspaceName(resolvedName).valid) {
+              break;
+            }
+            candidateParent = candidateParent.slice(0, -1);
+          }
+
+          if (!validateWorkspaceName(resolvedName).valid) {
+            resolvedName = generateForkBranchName(candidateParent, existingNames);
+          }
+        }
+      } else {
+        resolvedName = newName;
+      }
+
+      const resolvedNameValidation = validateWorkspaceName(resolvedName);
+      if (!resolvedNameValidation.valid) {
+        return Err(resolvedNameValidation.error ?? "Invalid workspace name");
+      }
+
       const runtime = createRuntime(sourceRuntimeConfig, {
         projectPath: foundProjectPath,
         workspaceName: sourceMetadata.name,
@@ -2573,7 +2808,7 @@ export class WorkspaceService extends EventEmitter {
       const forkResult = await runtime.forkWorkspace({
         projectPath: foundProjectPath,
         sourceWorkspaceName: sourceMetadata.name,
-        newWorkspaceName: newName,
+        newWorkspaceName: resolvedName,
         initLogger,
       });
 
@@ -2592,7 +2827,7 @@ export class WorkspaceService extends EventEmitter {
         runtime,
         {
           projectPath: foundProjectPath,
-          branchName: newName,
+          branchName: resolvedName,
           trunkBranch: forkResult.sourceBranch ?? "main",
           workspacePath: forkResult.workspacePath!,
           initLogger,
@@ -2609,46 +2844,20 @@ export class WorkspaceService extends EventEmitter {
       try {
         await fsPromises.mkdir(newSessionDir, { recursive: true });
 
-        const sourceChatPath = path.join(sourceSessionDir, "chat.jsonl");
-        const newChatPath = path.join(newSessionDir, "chat.jsonl");
-        try {
-          await fsPromises.copyFile(sourceChatPath, newChatPath);
-        } catch (error) {
-          if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-            throw error;
-          }
-        }
-
-        const sourcePartialPath = path.join(sourceSessionDir, "partial.json");
-        const newPartialPath = path.join(newSessionDir, "partial.json");
-        try {
-          await fsPromises.copyFile(sourcePartialPath, newPartialPath);
-        } catch (error) {
-          if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-            throw error;
-          }
-        }
-
-        const sourceTimingPath = path.join(sourceSessionDir, "session-timing.json");
-        const newTimingPath = path.join(newSessionDir, "session-timing.json");
-        try {
-          await fsPromises.copyFile(sourceTimingPath, newTimingPath);
-        } catch (error) {
-          if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-            throw error;
-          }
-        }
-        const sourceUsagePath = path.join(sourceSessionDir, "session-usage.json");
-        const newUsagePath = path.join(newSessionDir, "session-usage.json");
-        try {
-          await fsPromises.copyFile(sourceUsagePath, newUsagePath);
-        } catch (error) {
-          if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
-            throw error;
-          }
+        const sessionFiles = [
+          "chat.jsonl",
+          "partial.json",
+          "session-timing.json",
+          "session-usage.json",
+        ] as const;
+        for (const fileName of sessionFiles) {
+          await copyIfExists(
+            path.join(sourceSessionDir, fileName),
+            path.join(newSessionDir, fileName)
+          );
         }
       } catch (copyError) {
-        await runtime.deleteWorkspace(foundProjectPath, newName, true);
+        await runtime.deleteWorkspace(foundProjectPath, resolvedName, true);
         try {
           await fsPromises.rm(newSessionDir, { recursive: true, force: true });
         } catch (cleanupError) {
@@ -2660,7 +2869,13 @@ export class WorkspaceService extends EventEmitter {
       }
 
       // Copy plan file if it exists (checks both new and legacy paths)
-      await copyPlanFile(runtime, sourceMetadata.name, sourceWorkspaceId, newName, projectName);
+      await copyPlanFile(
+        runtime,
+        sourceMetadata.name,
+        sourceWorkspaceId,
+        resolvedName,
+        projectName
+      );
 
       // Apply runtime-provided config updates (e.g., Coder marks shared workspaces)
       const { forkedRuntimeConfig } = await applyForkRuntimeUpdates(
@@ -2683,11 +2898,11 @@ export class WorkspaceService extends EventEmitter {
       }
 
       // Compute namedWorkspacePath for frontend metadata
-      const namedWorkspacePath = runtime.getWorkspacePath(foundProjectPath, newName);
+      const namedWorkspacePath = runtime.getWorkspacePath(foundProjectPath, resolvedName);
 
       const metadata: FrontendWorkspaceMetadata = {
         id: newWorkspaceId,
-        name: newName,
+        name: resolvedName,
         projectName,
         projectPath: foundProjectPath,
         createdAt: new Date().toISOString(),
@@ -2695,6 +2910,17 @@ export class WorkspaceService extends EventEmitter {
         namedWorkspacePath,
         // Preserve workspace organization when forking via /fork.
         sectionId: sourceMetadata.sectionId,
+        // Seamless fork: generate a numbered title like "Parent Title (1)".
+        ...(isAutoName
+          ? {
+              title: generateForkTitle(
+                sourceMetadata.title ?? sourceMetadata.name,
+                allMetadata
+                  .filter((m) => m.projectPath === foundProjectPath)
+                  .map((m) => m.title ?? m.name)
+              ),
+            }
+          : {}),
       };
 
       await this.config.addWorkspace(foundProjectPath, metadata);
diff --git a/src/node/services/workspaceTitleGenerator.ts b/src/node/services/workspaceTitleGenerator.ts
index 22e3792d92..c394566eb5 100644
--- a/src/node/services/workspaceTitleGenerator.ts
+++ b/src/node/services/workspaceTitleGenerator.ts
@@ -272,7 +272,9 @@ export function mapModelCreationError(
 export async function generateWorkspaceIdentity(
   message: string,
   candidates: string[],
-  aiService: AIService
+  aiService: AIService,
+  /** Optional prior assistant message for additional context (e.g. forked history). Truncated to 500 chars. */
+  assistantContext?: string
 ): Promise<Result<GenerateWorkspaceIdentityResult, NameGenerationError>> {
   if (candidates.length === 0) {
     return Err({ type: "unknown", raw: "No model candidates provided for name generation" });
@@ -305,7 +307,7 @@ export async function generateWorkspaceIdentity(
         output: Output.object({ schema: workspaceIdentitySchema }),
         prompt: `Generate a workspace name and title for this development task:
 
-"${message}"
+${assistantContext ? `Assistant: "${assistantContext.slice(0, 500)}"\n\nUser: "${message}"` : `"${message}"`}
 
 Requirements:
 - name: The area of the codebase being worked on (1-2 words, max 15 chars, git-safe: lowercase, hyphens only). Random bytes will be appended for uniqueness, so focus on the area not the specific task. Examples: "sidebar", "auth", "config", "api"
diff --git a/tests/ui/chat/sections.test.ts b/tests/ui/chat/sections.test.ts
index 259fc2c26f..b5408180ab 100644
--- a/tests/ui/chat/sections.test.ts
+++ b/tests/ui/chat/sections.test.ts
@@ -18,7 +18,6 @@
 
 import "../dom";
 import { act, fireEvent, waitFor } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
 
 import { shouldRunIntegrationTests } from "../../testUtils";
 import {
@@ -48,17 +47,6 @@ function findWorkspaceRow(container: HTMLElement, workspaceId: string): HTMLElem
   return container.querySelector(`[data-workspace-id="${workspaceId}"]`);
 }
 
-/**
- * Find a workspace row in the sidebar by its displayed title (usually the workspace name).
- *
- * Note: We include `data-workspace-path` to avoid matching nested buttons/inputs that also
- * carry `data-workspace-id`.
- */
-function findWorkspaceRowByTitle(container: HTMLElement, title: string): HTMLElement | null {
-  const rows = container.querySelectorAll<HTMLElement>("[data-workspace-id][data-workspace-path]");
-  return Array.from(rows).find((row) => row.getAttribute("aria-label")?.includes(title)) ?? null;
-}
-
 /**
  * Find a section drop zone in the sidebar by section ID.
  */
@@ -328,7 +316,7 @@ describeIntegration("Workspace Sections", () => {
     }
   }, 60_000);
 
-  test("/fork preserves section assignment", async () => {
+  test("fork API preserves section assignment", async () => {
     const env = getSharedEnv();
     const projectPath = getSharedRepoPath();
     const trunkBranch = await detectDefaultTrunkBranch(projectPath);
@@ -359,102 +347,43 @@ describeIntegration("Workspace Sections", () => {
       }
 
       sourceWorkspaceId = sourceWsResult.metadata.id;
-      const sourceMetadata = sourceWsResult.metadata;
-
-      const cleanupDom = installDom();
-      expandProjects([projectPath]);
-
-      // Render with the source workspace selected so we can run /fork from the chat input.
-      const view = renderApp({ apiClient: env.orpc, metadata: sourceMetadata });
-
-      try {
-        await setupWorkspaceView(view, sourceMetadata, sourceWorkspaceId);
-
-        const forkedName = generateBranchName("forked-in-section");
-
-        const user = userEvent.setup({ document: view.container.ownerDocument });
-        const textarea = await waitFor(
-          () => {
-            // There can be multiple ChatInput instances mounted (e.g., ProjectPage + Workspace view).
-            // Use the last enabled textarea in DOM order to target the active workspace view.
-            const textareas = Array.from(
-              view.container.querySelectorAll('textarea[aria-label="Message Claude"]')
-            ) as HTMLTextAreaElement[];
-
-            if (textareas.length === 0) {
-              throw new Error("Chat textarea not found");
-            }
-
-            const enabled = [...textareas].reverse().find((el) => !el.disabled);
-            if (!enabled) {
-              throw new Error(`Chat textarea is disabled (found ${textareas.length})`);
-            }
-
-            return enabled;
-          },
-          { timeout: 10_000 }
-        );
-
-        textarea.focus();
-        await user.clear(textarea);
-        await user.type(textarea, `/fork ${forkedName}`);
-
-        const chatInputSection = textarea.closest('[data-component="ChatInputSection"]');
-        if (!chatInputSection) {
-          throw new Error("ChatInputSection not found for textarea");
-        }
-
-        const sendButton = await waitFor(
-          () => {
-            const el = chatInputSection.querySelector(
-              'button[aria-label="Send message"]'
-            ) as HTMLButtonElement | null;
-            if (!el) {
-              throw new Error("Send button not found");
-            }
-            if (el.disabled) {
-              throw new Error("Send button disabled");
-            }
-            return el;
-          },
-          { timeout: 10_000 }
-        );
-
-        await user.click(sendButton);
-
-        // Wait for the forked workspace to appear in the sidebar.
-        // The fork may navigate to the new workspace immediately (navigation
-        // is synchronous / normal priority), so we verify success through the
-        // sidebar rather than checking for a transient chat message.
-        await waitFor(
-          () => {
-            const workspaceRow = findWorkspaceRowByTitle(view.container, forkedName);
-            if (!workspaceRow) {
-              throw new Error(`Forked workspace row "${forkedName}" not found in sidebar`);
-            }
-
-            forkedWorkspaceId = workspaceRow.getAttribute("data-workspace-id") ?? undefined;
-            if (!forkedWorkspaceId) {
-              throw new Error("Forked workspace row missing data-workspace-id");
-            }
-
-            // The key behavior: the forked workspace stays in the same section.
-            expect(workspaceRow.getAttribute("data-section-id")).toBe(sectionId);
-          },
-          { timeout: 30_000 }
-        );
-      } finally {
-        await cleanupView(view, cleanupDom);
+
+      const forkedName = generateBranchName("forked-in-section");
+      const forkResult = await env.orpc.workspace.fork({
+        sourceWorkspaceId,
+        newName: forkedName,
+      });
+      if (!forkResult.success) {
+        throw new Error(`Failed to fork workspace: ${forkResult.error}`);
       }
+
+      forkedWorkspaceId = forkResult.metadata.id;
+      expect(forkResult.metadata.sectionId).toBe(sectionId);
     } finally {
+      // Best-effort cleanup: remove any workspaces still assigned to this section,
+      // even if the assertion failed before we captured forkedWorkspaceId.
+      const activeWorkspaces = await env.orpc.workspace.list();
+      const sectionWorkspaceIds = activeWorkspaces
+        .filter((workspace) => workspace.sectionId === sectionId)
+        .map((workspace) => workspace.id);
+
       if (forkedWorkspaceId) {
-        await env.orpc.workspace.remove({ workspaceId: forkedWorkspaceId });
+        sectionWorkspaceIds.push(forkedWorkspaceId);
       }
       if (sourceWorkspaceId) {
-        await env.orpc.workspace.remove({ workspaceId: sourceWorkspaceId });
+        sectionWorkspaceIds.push(sourceWorkspaceId);
       }
-      await env.orpc.workspace.remove({ workspaceId: setupWs.metadata.id });
-      await env.orpc.projects.sections.remove({ projectPath, sectionId });
+
+      const uniqueWorkspaceIds = [...new Set(sectionWorkspaceIds)].filter(
+        (workspaceId) => workspaceId !== setupWs.metadata.id
+      );
+
+      for (const workspaceId of uniqueWorkspaceIds) {
+        await env.orpc.workspace.remove({ workspaceId }).catch(() => {});
+      }
+
+      await env.orpc.workspace.remove({ workspaceId: setupWs.metadata.id }).catch(() => {});
+      await env.orpc.projects.sections.remove({ projectPath, sectionId }).catch(() => {});
     }
   }, 60_000);
   // ─────────────────────────────────────────────────────────────────────────────
@@ -494,9 +423,13 @@ describeIntegration("Workspace Sections", () => {
     if (!sectionC.success) throw new Error(`Failed to create section: ${sectionC.error}`);
 
     try {
-      // Verify initial order
+      // Verify initial order for the sections created in this test.
       let sections = await env.orpc.projects.sections.list({ projectPath });
-      expect(sections.map((s) => s.name)).toEqual(["Section A", "Section B", "Section C"]);
+      const trackedSectionIds = [sectionA.data.id, sectionB.data.id, sectionC.data.id];
+      const trackedInitialOrder = sections
+        .filter((section) => trackedSectionIds.includes(section.id))
+        .map((section) => section.name);
+      expect(trackedInitialOrder).toEqual(["Section A", "Section B", "Section C"]);
 
       // Reorder to C, A, B
       const reorderResult = await env.orpc.projects.sections.reorder({
@@ -505,9 +438,12 @@ describeIntegration("Workspace Sections", () => {
       });
       expect(reorderResult.success).toBe(true);
 
-      // Verify new order
+      // Verify new order for the sections created in this test.
       sections = await env.orpc.projects.sections.list({ projectPath });
-      expect(sections.map((s) => s.name)).toEqual(["Section C", "Section A", "Section B"]);
+      const trackedReordered = sections
+        .filter((section) => trackedSectionIds.includes(section.id))
+        .map((section) => section.name);
+      expect(trackedReordered).toEqual(["Section C", "Section A", "Section B"]);
     } finally {
       await env.orpc.workspace.remove({ workspaceId: setupWs.metadata.id });
       await env.orpc.projects.sections.remove({ projectPath, sectionId: sectionA.data.id });
@@ -558,9 +494,13 @@ describeIntegration("Workspace Sections", () => {
       await waitForSection(view.container, sectionFirst.data.id);
       await waitForSection(view.container, sectionSecond.data.id);
 
-      // Verify DOM order matches linked-list order (First -> Second)
+      // Verify DOM order matches linked-list order (First -> Second) for the
+      // sections created in this test. Other sections may exist from unrelated setup.
       const orderedIds = getSectionIdsInOrder(view.container);
-      expect(orderedIds).toEqual([sectionFirst.data.id, sectionSecond.data.id]);
+      const trackedOrder = orderedIds.filter(
+        (id) => id === sectionFirst.data.id || id === sectionSecond.data.id
+      );
+      expect(trackedOrder).toEqual([sectionFirst.data.id, sectionSecond.data.id]);
     } finally {
       await cleanupView(view, cleanupDom);
       await env.orpc.workspace.remove({ workspaceId: setupWs.metadata.id });
diff --git a/tests/ui/workspaces/fork.test.ts b/tests/ui/workspaces/fork.test.ts
index d13798e084..034978ba08 100644
--- a/tests/ui/workspaces/fork.test.ts
+++ b/tests/ui/workspaces/fork.test.ts
@@ -1,17 +1,16 @@
 /**
  * Integration tests for workspace forking UX.
  *
- * Regression test: after running `/fork <name>` from a workspace, the newly-created
+ * Regression test: after running `/fork` from a workspace, the newly-created
  * workspace should appear in the sidebar immediately (i.e. without being hidden
  * under an "older" age tier).
  */
 
 import "../dom";
-import { waitFor } from "@testing-library/react";
+import { fireEvent, waitFor } from "@testing-library/react";
 
 import { shouldRunIntegrationTests } from "../../testUtils";
 import { preloadTestModules } from "../../ipc/setup";
-import { generateBranchName } from "../../ipc/helpers";
 
 import { createAppHarness } from "../harness";
 
@@ -33,8 +32,8 @@ describeIntegration("Workspace Fork (UI)", () => {
       await app.chat.send("Hello from source workspace");
       await app.chat.expectTranscriptContains("Mock response: Hello from source workspace");
 
-      const forkBranch = generateBranchName("ui-fork-child");
-      await app.chat.send(`/fork ${forkBranch}`);
+      // Seamless fork: no name argument needed; backend auto-generates branch name
+      await app.chat.send("/fork");
 
       // Wait for navigation to the forked workspace.
       await waitFor(
@@ -81,4 +80,84 @@ describeIntegration("Workspace Fork (UI)", () => {
       await app.dispose();
     }
   }, 60_000);
+
+  test("context menu Fork chat action adds the new workspace to the sidebar immediately", async () => {
+    const app = await createAppHarness({ branchPrefix: "ui-fork-menu" });
+
+    let forkedWorkspaceId: string | null = null;
+
+    try {
+      // Ensure the source workspace has a non-zero recency so that age-tier bucketing
+      // is active (otherwise "always show one workspace" can mask regressions).
+      await app.chat.send("Hello from source workspace");
+      await app.chat.expectTranscriptContains("Mock response: Hello from source workspace");
+
+      const sourceDisplayTitle = app.metadata.title ?? app.metadata.name;
+
+      const menuButton = await waitFor(
+        () => {
+          const btn = app.view.container.querySelector(
+            `[aria-label="Workspace actions for ${sourceDisplayTitle}"]`
+          ) as HTMLElement | null;
+          if (!btn) throw new Error("Workspace actions menu button not found");
+          return btn;
+        },
+        { timeout: 5_000 }
+      );
+      fireEvent.click(menuButton);
+
+      const forkButton = await waitFor(
+        () => {
+          const buttons = Array.from(document.querySelectorAll("button"));
+          const forkBtn = buttons.find((b) => b.textContent?.includes("Fork chat"));
+          if (!forkBtn) throw new Error("Fork button not found in menu");
+          return forkBtn as HTMLElement;
+        },
+        { timeout: 5_000 }
+      );
+      fireEvent.click(forkButton);
+
+      // Wait for navigation to the forked workspace.
+      await waitFor(
+        () => {
+          const path = window.location.pathname;
+          if (!path.startsWith("/workspace/")) {
+            throw new Error(`Unexpected path after fork: ${path}`);
+          }
+
+          const currentId = decodeURIComponent(path.slice("/workspace/".length));
+          if (currentId === app.workspaceId) {
+            throw new Error("Still on source workspace after fork");
+          }
+
+          forkedWorkspaceId = currentId;
+        },
+        { timeout: 10_000 }
+      );
+
+      if (!forkedWorkspaceId) {
+        throw new Error("Missing forked workspace ID after navigation");
+      }
+
+      await waitFor(
+        () => {
+          const el = app.view.container.querySelector(
+            `[data-workspace-id=\"${forkedWorkspaceId}\"]`
+          ) as HTMLElement | null;
+          if (!el) {
+            throw new Error("Forked workspace not found in sidebar");
+          }
+        },
+        { timeout: 1_000 }
+      );
+    } finally {
+      if (forkedWorkspaceId) {
+        await app.env.orpc.workspace
+          .remove({ workspaceId: forkedWorkspaceId, options: { force: true } })
+          .catch(() => {});
+      }
+
+      await app.dispose();
+    }
+  }, 60_000);
 });