@@ -53,6 +53,11 @@ export interface WidgetDefinition<Props> extends Navigation {
 	readonly minHeight: number;
 	/** "one" allows a single instance (the shell hides duplicate). */
 	readonly cardinality: "one" | "many";
+	/**
+	 * This widget sets its workspace tab (the frame's `setTab`), possibly once it has loaded. Until it
+	 * does, the tab keeps what it showed rather than flashing this frame's default title.
+	 */
+	readonly ownsTab?: boolean;
 	/** Validates an instance's saved settings before they reach the component. */
 	readonly props: Schema.Decoder<Props>;
 	readonly component: ComponentType<WidgetProps<Props>>;
@@ -66,6 +71,7 @@ export interface Widget extends Navigation {
 	readonly minWidth: number;
 	readonly minHeight: number;
 	readonly cardinality: "one" | "many";
+	readonly ownsTab?: boolean;
 	render(instance: {
 		readonly instanceId: string;
 		readonly props: unknown;
 
@@ -1,9 +1,11 @@
 import { useAtomValue } from "@effect/atom-react";
 import { Link } from "@tanstack/react-router";
-import { Fragment } from "react";
+import { Fragment, useRef } from "react";
 
 import { isMac } from "../kernel/platform";
-import { chromeAtom, chromeOf, focusedAtom } from "../wm/chrome";
+import type { Tab } from "../sdk";
+import { registry } from "../widgets";
+import { chromeAtom, chromeOf, focusedAtom, tabOwnerAtom } from "../wm/chrome";
 import { deskAtom } from "../wm/instances";
 import { type Workspace, workspaceRoute, workspaceTag } from "../wm/workspaces";
 import { iconOf } from "./icons";
@@ -22,10 +24,22 @@ export function Switcher({ workspaces, active }: SwitcherProps) {
 	const { instances, order } = useAtomValue(deskAtom);
 	const chrome = useAtomValue(chromeAtom);
 	const focusedOn = useAtomValue(focusedAtom);
+	const owners = useAtomValue(tabOwnerAtom);
+	// What each tab showed last, kept while a frame that will set the tab is still loading.
+	const shown = useRef(new Map<string, Tab>());
 	const showing = (workspace: Workspace) => {
+		const tab = tabOf(workspace);
+		shown.current.set(workspace.id, tab);
+		return tab;
+	};
+	const tabOf = (workspace: Workspace): Tab => {
 		const tag = workspaceTag(workspace);
 		const onWorkspace = (instance: (typeof instances)[number] | undefined) =>
 			instance !== undefined && (instance.tags & tag) !== 0;
+		// The frame that claimed the tab keeps it while it is still on this workspace.
+		const owner = instances.find((instance) => instance.id === owners.get(workspace.id));
+		const claimed = owner !== undefined && onWorkspace(owner) ? chrome.get(owner.id)?.tab : undefined;
+		if (claimed !== undefined) return claimed;
 		// Its own last focus once it has been on screen, else its main frame (first in tile order), so
 		// focusing a frame shared with another workspace never relabels a tab not yet visited.
 		const remembered = instances.find((instance) => instance.id === focusedOn.get(workspace.id));
@@ -36,6 +50,8 @@ export function Switcher({ workspaces, active }: SwitcherProps) {
 		const frame = chrome.get(focused.id);
 		// The focused frame decides what the tab says; without a say, the workspace's name over its title.
 		if (frame?.tab !== undefined) return frame.tab;
+		const kept = shown.current.get(workspace.id);
+		if (registry.get(focused.kind)?.ownsTab === true && kept !== undefined) return kept;
 		const title = chromeOf(focused, frame).title;
 		// A frame named like its workspace adds nothing to the tab.
 		return title.toLowerCase() === workspace.name.toLowerCase()
 
@@ -28,6 +28,7 @@ export const session = defineWidget({
 	cardinality: "many",
 	priority: "builtin",
 	opens: ["codework://session/*"],
+	ownsTab: true,
 	replaceable: true,
 	props: Schema.Struct({}),
 	component: Session,
 
@@ -25,6 +25,13 @@ export const chromeAtom = Atom.make<ReadonlyMap<string, Chrome>>(new Map()).pipe
  */
 export const focusedAtom = Atom.make<ReadonlyMap<string, string>>(new Map()).pipe(Atom.keepAlive);
 
+/**
+ * The frame that owns each workspace's tab (workspace id → instance id): the last one focused there
+ * that set a tab. Focus alone does not move the tab, so clicking a frame with no tab of its own, or
+ * opening one that has not set it yet, leaves the tab as it was instead of flickering through both.
+ */
+export const tabOwnerAtom = Atom.make<ReadonlyMap<string, string>>(new Map()).pipe(Atom.keepAlive);
+
 /** A frame's title and icon: what the widget set, else the instance's, else its definition's. */
 export function chromeOf(instance: Instance, chrome: Chrome | undefined) {
 	const definition = registry.get(instance.kind);
 
@@ -19,7 +19,7 @@ import { useArrangedWidgets, useElementSize } from "webwm/react";
 import type { Frame as FrameApi, Shell } from "../sdk";
 import { FrameContext, ShellContext } from "../sdk/shell";
 import { builtins, registry } from "../widgets";
-import { type Chrome, chromeAtom, chromeOf, focusedAtom } from "./chrome";
+import { type Chrome, chromeAtom, chromeOf, focusedAtom, tabOwnerAtom } from "./chrome";
 import { Divider } from "./divider";
 import { Frame } from "./frame";
 import { add, deskAtom, type Instance, remove, retarget, focus as raise, update } from "./instances";
@@ -151,6 +151,15 @@ export function Desktop({ workspace }: DesktopProps) {
 			current.get(workspace.id) === focusedId ? current : new Map(current).set(workspace.id, focusedId),
 		);
 	}, [workspace.id, focusedId, setFocused]);
+	// The focused frame takes the tab once it has one to show, which may be after it loads.
+	const focusedTab = focusedId === undefined ? undefined : chrome.get(focusedId)?.tab;
+	const setTabOwner = useAtomSet(tabOwnerAtom);
+	useEffect(() => {
+		if (focusedId === undefined || focusedTab === undefined) return;
+		setTabOwner((current) =>
+			current.get(workspace.id) === focusedId ? current : new Map(current).set(workspace.id, focusedId),
+		);
+	}, [workspace.id, focusedId, focusedTab, setTabOwner]);
 	const bounds: Bounds = { x: 0, y: 0, w: size.width, h: size.height };
 	const tiled = order.tileOrder.flatMap((id) =>
 		widgets.filter((widget) => widget.id === id && isVisible(widget, activeTags)),