diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarWorkspaceItem/DashboardSidebarWorkspaceItem.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarWorkspaceItem/DashboardSidebarWorkspaceItem.tsx
index e6afb5f8e8d..748ccaa887f 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarWorkspaceItem/DashboardSidebarWorkspaceItem.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarWorkspaceItem/DashboardSidebarWorkspaceItem.tsx
@@ -4,7 +4,7 @@ import { useOptimisticCollectionActions } from "renderer/routes/_authenticated/h
 import { useDeletingWorkspaces } from "renderer/routes/_authenticated/providers/DeletingWorkspacesProvider";
 import { RenameBranchDialog } from "renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/components";
 import { useV2WorkspaceNotificationStatus } from "renderer/stores/v2-notifications";
-import { useWorkspaceCreateFailuresStore } from "renderer/stores/workspace-creates";
+import { useWorkspaceCreatesStore } from "renderer/stores/workspace-creates";
 import { useDashboardSidebarHover } from "../../providers/DashboardSidebarHoverProvider";
 import type { DashboardSidebarWorkspace } from "../../types";
 import { DashboardSidebarDeleteDialog } from "../DashboardSidebarDeleteDialog";
@@ -83,7 +83,7 @@ export function DashboardSidebarWorkspaceItem({
 	const isDeleting = useDeletingWorkspaces().isDeleting(id);
 
 	const handleDismissInFlight = useCallback(() => {
-		useWorkspaceCreateFailuresStore.getState().clear(id);
+		useWorkspaceCreatesStore.getState().remove(id);
 	}, [id]);
 
 	const {
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useDashboardSidebarData/useDashboardSidebarData.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useDashboardSidebarData/useDashboardSidebarData.ts
index f5b427c5def..7d2189cfedb 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useDashboardSidebarData/useDashboardSidebarData.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useDashboardSidebarData/useDashboardSidebarData.ts
@@ -8,7 +8,7 @@ import { useDashboardSidebarState } from "renderer/routes/_authenticated/hooks/u
 import { useCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider";
 import { getVisibleSidebarWorkspaces } from "renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal";
 import { useLocalHostService } from "renderer/routes/_authenticated/providers/LocalHostServiceProvider";
-import { useWorkspaceCreateFailuresStore } from "renderer/stores/workspace-creates";
+import { useWorkspaceCreatesStore } from "renderer/stores/workspace-creates";
 import type {
 	DashboardSidebarProject,
 	DashboardSidebarProjectChild,
@@ -132,23 +132,26 @@ export function useDashboardSidebarData() {
 	const { toggleProjectCollapsed } = useDashboardSidebarState();
 	const queryClient = useQueryClient();
 
-	// Failed workspace.create operations — backing v2_workspaces row was rolled
-	// back, but we keep the snapshot in renderer memory so the user can retry
-	// from the detail page or dismiss from the sidebar.
-	const failuresMap = useWorkspaceCreateFailuresStore(
-		(store) => store.failures,
-	);
-	const failureSidebarRows = useMemo(
+	// In-flight workspace.create operations. These don't have a backing DB row
+	// — they're kept in renderer memory until the real v2Workspaces row arrives
+	// via Electric sync (or until error/dismiss).
+	const inFlightEntries = useWorkspaceCreatesStore((store) => store.entries);
+	const inFlightSidebarRows = useMemo(
 		() =>
-			Object.entries(failuresMap).map(([id, entry]) => ({
-				id,
-				projectId: entry.snapshot.projectId,
-				hostId: entry.hostId,
-				name: entry.snapshot.name ?? "New workspace",
-				branchName:
-					entry.snapshot.branch ?? entry.snapshot.name ?? "New workspace",
-			})),
-		[failuresMap],
+			inFlightEntries
+				.filter((entry) => entry.snapshot.id !== undefined)
+				.map((entry) => ({
+					id: entry.snapshot.id as string,
+					projectId: entry.snapshot.projectId,
+					name: entry.snapshot.name ?? "New workspace",
+					branchName:
+						entry.snapshot.branch ?? entry.snapshot.name ?? "New workspace",
+					status:
+						entry.state === "creating"
+							? ("creating" as const)
+							: ("failed" as const),
+				})),
+		[inFlightEntries],
 	);
 
 	const { data: hosts = [] } = useLiveQuery(
@@ -243,7 +246,6 @@ export function useDashboardSidebarData() {
 					branch: workspaces.branch,
 					createdAt: workspaces.createdAt,
 					updatedAt: workspaces.updatedAt,
-					synced: workspaces.$synced,
 					tabOrder: sidebarWorkspaces.sidebarState.tabOrder,
 					sectionId: sidebarWorkspaces.sidebarState.sectionId,
 					isHidden: sidebarWorkspaces.sidebarState.isHidden,
@@ -261,13 +263,14 @@ export function useDashboardSidebarData() {
 		[rawSidebarWorkspaces],
 	);
 
-	const { data: localWorkspaceCandidates = [] } = useLiveQuery(
+	const { data: localMainWorkspaces = [] } = useLiveQuery(
 		(q) =>
 			q
 				.from({ workspaces: collections.v2Workspaces })
 				.innerJoin({ hosts: collections.v2Hosts }, ({ workspaces, hosts }) =>
 					eq(workspaces.hostId, hosts.machineId),
 				)
+				.where(({ workspaces }) => eq(workspaces.type, "main"))
 				.select(({ workspaces, hosts }) => ({
 					id: workspaces.id,
 					projectId: workspaces.projectId,
@@ -278,7 +281,8 @@ export function useDashboardSidebarData() {
 					branch: workspaces.branch,
 					createdAt: workspaces.createdAt,
 					updatedAt: workspaces.updatedAt,
-					synced: workspaces.$synced,
+					tabOrder: MAIN_WORKSPACE_TAB_ORDER,
+					sectionId: null as string | null,
 				})),
 		[collections],
 	);
@@ -287,40 +291,17 @@ export function useDashboardSidebarData() {
 		const sidebarProjectIds = new Set(
 			sidebarProjects.map((project) => project.id),
 		);
-		const autoIncluded = localWorkspaceCandidates
-			.filter((workspace) => {
-				if (localStateWorkspaceIds.has(workspace.id)) return false;
-				if (workspace.hostId !== machineId) return false;
-				if (!sidebarProjectIds.has(workspace.projectId)) return false;
-				if (workspace.type === "main") return true;
-				return workspace.type === "worktree" && workspace.synced === false;
-			})
-			.map((workspace) => ({
-				...workspace,
-				tabOrder:
-					workspace.type === "main"
-						? MAIN_WORKSPACE_TAB_ORDER
-						: PENDING_WORKSPACE_TAB_ORDER,
-				sectionId: null as string | null,
-				creationStatus:
-					workspace.synced === false ? ("creating" as const) : undefined,
-			}));
-		// Pinned rows (those with v2WorkspaceLocalState) keep showing the
-		// creating spinner until Electric confirms `$synced`. The detail page
-		// reads `$synced` directly off the row, so without this the sidebar
-		// would clear its spinner the moment local state was inserted in
-		// `onInsert`, while the detail page would still show
-		// `WorkspaceCreatingState` until the shape stream caught up.
-		const sidebarWithSyncMeta = sidebarWorkspaces.map((workspace) => ({
-			...workspace,
-			creationStatus:
-				workspace.synced === false ? ("creating" as const) : undefined,
-		}));
-
-		return [...autoIncluded, ...sidebarWithSyncMeta];
+		const autoLocalMainWorkspaces = localMainWorkspaces.filter(
+			(workspace) =>
+				!localStateWorkspaceIds.has(workspace.id) &&
+				workspace.hostId === machineId &&
+				sidebarProjectIds.has(workspace.projectId),
+		);
+
+		return [...autoLocalMainWorkspaces, ...sidebarWorkspaces];
 	}, [
+		localMainWorkspaces,
 		localStateWorkspaceIds,
-		localWorkspaceCandidates,
 		machineId,
 		sidebarProjects,
 		sidebarWorkspaces,
@@ -461,7 +442,6 @@ export function useDashboardSidebarData() {
 				behindCount: null,
 				createdAt: workspace.createdAt,
 				updatedAt: workspace.updatedAt,
-				creationStatus: workspace.creationStatus,
 			};
 
 			if (workspace.sectionId) {
@@ -484,25 +464,23 @@ export function useDashboardSidebarData() {
 			});
 		}
 
-		// Inject failed workspace.create rows from the renderer failure store.
-		// The optimistic v2_workspaces row was rolled back, so the only signal
-		// left is the snapshot we kept in memory for retry/dismiss.
-		for (const failure of failureSidebarRows) {
-			if (localStateWorkspaceIds.has(failure.id)) continue;
-			const project = projectsById.get(failure.projectId);
+		// Inject in-flight workspaces (creating / failed) from the renderer-side
+		// in-flight store.
+		for (const pw of inFlightSidebarRows) {
+			if (localStateWorkspaceIds.has(pw.id)) continue;
+			const project = projectsById.get(pw.projectId);
 			if (!project) continue;
 
-			const failedItem: DashboardSidebarWorkspace = {
-				id: failure.id,
-				projectId: failure.projectId,
-				hostId: failure.hostId,
-				hostType:
-					failure.hostId === machineId ? "local-device" : "remote-device",
+			const pendingItem: DashboardSidebarWorkspace = {
+				id: pw.id,
+				projectId: pw.projectId,
+				hostId: "",
+				hostType: "local-device",
 				type: "worktree",
 				hostIsOnline: null,
 				accentColor: null,
-				name: failure.name,
-				branch: failure.branchName,
+				name: pw.name,
+				branch: pw.branchName,
 				pullRequest: null,
 				repoUrl:
 					project.githubOwner && project.githubRepoName
@@ -514,14 +492,14 @@ export function useDashboardSidebarData() {
 				behindCount: null,
 				createdAt: new Date(),
 				updatedAt: new Date(),
-				creationStatus: "failed",
+				creationStatus: pw.status,
 			};
 
 			project.childEntries.push({
 				tabOrder: PENDING_WORKSPACE_TAB_ORDER,
 				child: {
 					type: "workspace",
-					workspace: failedItem,
+					workspace: pendingItem,
 				},
 			});
 		}
@@ -564,7 +542,7 @@ export function useDashboardSidebarData() {
 	}, [
 		machineId,
 		pullRequestsByWorkspaceId,
-		failureSidebarRows,
+		inFlightSidebarRows,
 		localStateWorkspaceIds,
 		sidebarProjects,
 		sidebarSections,
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/layout.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/layout.tsx
index e0544216216..f3cdabbafce 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/layout.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/layout.tsx
@@ -14,6 +14,7 @@ import { ResizablePanel } from "renderer/screens/main/components/ResizablePanel"
 import { WorkspaceSidebar } from "renderer/screens/main/components/WorkspaceSidebar";
 import { DeleteWorkspaceDialog } from "renderer/screens/main/components/WorkspaceSidebar/WorkspaceListItem/components";
 import { useOpenNewWorkspaceModal } from "renderer/stores/new-workspace-modal";
+import { WorkspaceCreatesManager } from "renderer/stores/workspace-creates";
 import {
 	COLLAPSED_WORKSPACE_SIDEBAR_WIDTH,
 	DEFAULT_WORKSPACE_SIDEBAR_WIDTH,
@@ -127,6 +128,7 @@ function DashboardLayout() {
 
 	return (
 		<div className="flex h-full w-full overflow-hidden">
+			<WorkspaceCreatesManager />
 			{sidebarOutsideColumn && sidebarPanel}
 			<div className="flex flex-1 flex-col min-w-0 min-h-0">
 				<TopBar />
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/components/WorkspaceCreateErrorState/WorkspaceCreateErrorState.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/components/WorkspaceCreateErrorState/WorkspaceCreateErrorState.tsx
index c10b19a9714..282c9f5c5c9 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/components/WorkspaceCreateErrorState/WorkspaceCreateErrorState.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/components/WorkspaceCreateErrorState/WorkspaceCreateErrorState.tsx
@@ -1,10 +1,7 @@
 import { Button } from "@superset/ui/button";
+import { useNavigate } from "@tanstack/react-router";
 import { AlertCircle, GitBranch } from "lucide-react";
-import { useNavigateAwayFromWorkspace } from "renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useNavigateAwayFromWorkspace";
-import {
-	useWorkspaceCreateFailuresStore,
-	useWorkspaceCreates,
-} from "renderer/stores/workspace-creates";
+import { useWorkspaceCreates } from "renderer/stores/workspace-creates";
 
 interface WorkspaceCreateErrorStateProps {
 	workspaceId: string;
@@ -19,22 +16,12 @@ export function WorkspaceCreateErrorState({
 	branch,
 	error,
 }: WorkspaceCreateErrorStateProps) {
-	const { submit } = useWorkspaceCreates();
-	const navigateAway = useNavigateAwayFromWorkspace();
-
-	const handleRetry = () => {
-		const failure =
-			useWorkspaceCreateFailuresStore.getState().failures[workspaceId];
-		if (!failure) return;
-		void submit({ hostId: failure.hostId, snapshot: failure.snapshot });
-	};
+	const navigate = useNavigate();
+	const { retry, dismiss } = useWorkspaceCreates();
 
 	const handleDismiss = () => {
-		useWorkspaceCreateFailuresStore.getState().clear(workspaceId);
-		// `navigateAway` jumps to the next sidebar workspace when we're viewing
-		// the one being dismissed — falls back to the top sidebar entry since
-		// the failed id was never in the sidebar list, then to "/" if empty.
-		navigateAway(workspaceId);
+		dismiss(workspaceId);
+		void navigate({ to: "/v2-workspaces" });
 	};
 
 	return (
@@ -79,7 +66,7 @@ export function WorkspaceCreateErrorState({
 				</div>
 
 				<div className="flex items-center gap-2">
-					<Button size="sm" onClick={handleRetry}>
+					<Button size="sm" onClick={() => void retry(workspaceId)}>
 						Try again
 					</Button>
 					<Button size="sm" variant="ghost" onClick={handleDismiss}>
diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/layout.tsx b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/layout.tsx
index 123e8048c98..0e595b3c672 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/layout.tsx
+++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/v2-workspace/layout.tsx
@@ -4,7 +4,7 @@ import { createFileRoute, Outlet, useMatchRoute } from "@tanstack/react-router";
 import { useEffect, useRef } from "react";
 import { useDashboardSidebarState } from "renderer/routes/_authenticated/hooks/useDashboardSidebarState";
 import { useCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider";
-import { useWorkspaceCreateFailuresStore } from "renderer/stores/workspace-creates";
+import { useWorkspaceCreatesStore } from "renderer/stores/workspace-creates";
 import { WorkspaceCreateErrorState } from "./components/WorkspaceCreateErrorState";
 import { WorkspaceCreatingState } from "./components/WorkspaceCreatingState";
 import { WorkspaceNotFoundState } from "./components/WorkspaceNotFoundState";
@@ -34,47 +34,41 @@ function V2WorkspaceLayout() {
 		[collections, workspaceId],
 	);
 	const workspace = workspaces?.[0] ?? null;
-	// Read `$synced` straight off the row — useLiveQuery returns rows enriched
-	// with virtual props, and changes to optimistic state retrigger the query.
-	const isSynced = workspace?.$synced ?? false;
-	const failure = useWorkspaceCreateFailuresStore((store) =>
-		workspaceId ? store.failures[workspaceId] : undefined,
+	const inFlight = useWorkspaceCreatesStore((store) =>
+		workspaceId
+			? store.entries.find((entry) => entry.snapshot.id === workspaceId)
+			: undefined,
 	);
 
 	const lastEnsuredWorkspaceIdRef = useRef<string | null>(null);
 	useEffect(() => {
 		if (!workspace || lastEnsuredWorkspaceIdRef.current === workspace.id)
 			return;
-		// Only pin to the sidebar once the workspace is confirmed by the
-		// backend — pinning an optimistic row produces a sidebar state row
-		// that has to be cleaned up on rollback.
-		if (!isSynced) return;
 		lastEnsuredWorkspaceIdRef.current = workspace.id;
 		ensureWorkspaceInSidebar(workspace.id, workspace.projectId);
-	}, [ensureWorkspaceInSidebar, workspace, isSynced]);
+	}, [ensureWorkspaceInSidebar, workspace]);
 
 	if (!workspaceId || !isReady || !workspaces) {
 		return <div className="flex h-full w-full" />;
 	}
 
-	if (workspace && !isSynced) {
-		return (
-			<WorkspaceCreatingState
-				name={workspace.name}
-				branch={workspace.branch}
-				startedAt={workspace.createdAt.getTime()}
-			/>
-		);
-	}
-
 	if (!workspace) {
-		if (failure) {
+		if (inFlight?.state === "creating") {
+			return (
+				<WorkspaceCreatingState
+					name={inFlight.snapshot.name}
+					branch={inFlight.snapshot.branch}
+					startedAt={inFlight.startedAt}
+				/>
+			);
+		}
+		if (inFlight?.state === "error") {
 			return (
 				<WorkspaceCreateErrorState
 					workspaceId={workspaceId}
-					name={failure.snapshot.name}
-					branch={failure.snapshot.branch}
-					error={failure.error}
+					name={inFlight.snapshot.name}
+					branch={inFlight.snapshot.branch}
+					error={inFlight.error ?? "Unknown error"}
 				/>
 			);
 		}
diff --git a/apps/desktop/src/renderer/routes/_authenticated/hooks/useDashboardSidebarState/useDashboardSidebarState.ts b/apps/desktop/src/renderer/routes/_authenticated/hooks/useDashboardSidebarState/useDashboardSidebarState.ts
index 829d82a06ba..108ea0afb1f 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/hooks/useDashboardSidebarState/useDashboardSidebarState.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/hooks/useDashboardSidebarState/useDashboardSidebarState.ts
@@ -8,13 +8,26 @@ import {
 } from "renderer/routes/_authenticated/components/utils/paneLifecycleRows";
 import { useCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider";
 import type { AppCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider/collections";
-import {
-	getNextTabOrder,
-	getPrependTabOrder,
-	isSidebarWorkspaceVisible,
-} from "renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal";
+import { isSidebarWorkspaceVisible } from "renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal";
 import { PROJECT_CUSTOM_COLORS } from "shared/constants/project-colors";
 
+function getNextTabOrder(items: Array<{ tabOrder: number }>): number {
+	const maxTabOrder = items.reduce(
+		(maxValue, item) => Math.max(maxValue, item.tabOrder),
+		0,
+	);
+	return maxTabOrder + 1;
+}
+
+function getPrependTabOrder(items: Array<{ tabOrder: number }>): number {
+	if (items.length === 0) return 1;
+	const minTabOrder = items.reduce(
+		(minValue, item) => Math.min(minValue, item.tabOrder),
+		Number.POSITIVE_INFINITY,
+	);
+	return minTabOrder - 1;
+}
+
 type ProjectTopLevelItem = {
 	type: "workspace" | "section";
 	id: string;
diff --git a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/collections.ts b/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/collections.ts
index 12f7b02e194..a0c9e660d72 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/collections.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/collections.ts
@@ -22,7 +22,6 @@ import type {
 	SelectV2Workspace,
 	SelectWorkspace,
 } from "@superset/db/schema";
-import type { WorkspaceState } from "@superset/panes";
 import type { AppRouter } from "@superset/trpc";
 import { electricCollectionOptions } from "@tanstack/electric-db-collection";
 import {
@@ -41,13 +40,6 @@ import {
 import { createTRPCProxyClient, httpBatchLink } from "@trpc/client";
 import { env } from "renderer/env.renderer";
 import { getAuthToken, getJwt } from "renderer/lib/auth-client";
-import { getHostServiceClientByUrl } from "renderer/lib/host-service-client";
-import type { PaneViewerData } from "renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/types";
-import { appendLaunchesToPaneLayout } from "renderer/stores/workspace-creates/appendLaunchesToPaneLayout";
-import {
-	WorkspaceAlreadyExistsAtDifferentIdError,
-	type WorkspaceCreateMeta,
-} from "renderer/stores/workspace-creates/store";
 import superjson from "superjson";
 import { z } from "zod";
 import {
@@ -55,10 +47,8 @@ import {
 	type DashboardSidebarSectionRow,
 	dashboardSidebarProjectSchema,
 	dashboardSidebarSectionSchema,
-	getPrependTabOrder,
 	healV2UserPreferences,
 	healWorkspaceLocalState,
-	isSidebarWorkspaceVisible,
 	type V2TerminalPresetRow,
 	type V2UserPreferencesRow,
 	v2TerminalPresetSchema,
@@ -404,88 +394,6 @@ function createOrgCollections(organizationId: string): OrgCollections {
 				columnMapper,
 			},
 			getKey: (item) => item.id,
-			onInsert: async ({ transaction }) => {
-				const { modified, metadata } = transaction.mutations[0];
-				const meta = metadata as WorkspaceCreateMeta;
-				const client = getHostServiceClientByUrl(meta.hostUrl);
-				const result = await client.workspaces.create.mutate({
-					id: modified.id,
-					projectId: modified.projectId,
-					name: meta.providedName,
-					branch: meta.providedBranch,
-					pr: meta.pr,
-					baseBranch: meta.baseBranch,
-					taskId: modified.taskId ?? undefined,
-					agents: meta.agents,
-				});
-
-				if (result.alreadyExists && result.workspace.id !== modified.id) {
-					// Canonical row lives at a different id — roll back the optimistic
-					// row by throwing so Electric drops it. The submit hook catches
-					// this to redirect callers to the canonical id.
-					throw new WorkspaceAlreadyExistsAtDifferentIdError(
-						result.workspace.id,
-					);
-				}
-
-				// Mirror the post-create paneLayout setup that used to live in the
-				// renderer dispatch. Local-state writes are best-effort — the
-				// remote create has already succeeded, so a localStorage failure
-				// must NOT throw back to Electric (which would roll the row back
-				// even though the host wrote it). The next ensureWorkspaceInSidebar
-				// call (e.g. detail-page mount) will resync local state.
-				try {
-					const existing = v2WorkspaceLocalState.get(result.workspace.id);
-					const paneLayout = appendLaunchesToPaneLayout({
-						existing: existing?.paneLayout as
-							| WorkspaceState<PaneViewerData>
-							| undefined,
-						terminals: result.terminals,
-						agents: result.agents,
-					});
-					if (existing) {
-						v2WorkspaceLocalState.update(result.workspace.id, (draft) => {
-							draft.paneLayout = paneLayout;
-						});
-					} else {
-						// Prepend so the new workspace lands at the top of its project
-						// lane regardless of where existing tabOrders sit. Compute from
-						// the same project's visible top-level workspace rows.
-						const projectTabOrders = Array.from(
-							v2WorkspaceLocalState.state.values(),
-						)
-							.filter(
-								(row) =>
-									row.sidebarState.projectId === result.workspace.projectId &&
-									row.sidebarState.sectionId === null &&
-									isSidebarWorkspaceVisible(row),
-							)
-							.map((row) => ({ tabOrder: row.sidebarState.tabOrder }));
-						v2WorkspaceLocalState.insert({
-							workspaceId: result.workspace.id,
-							createdAt: new Date(),
-							sidebarState: {
-								projectId: result.workspace.projectId,
-								tabOrder: getPrependTabOrder(projectTabOrders),
-								sectionId: null,
-								changesFilter: { kind: "all" },
-								activeTab: "changes",
-								isHidden: false,
-							},
-							paneLayout,
-							viewedFiles: [],
-							recentlyViewedFiles: [],
-						});
-					}
-				} catch (err) {
-					console.warn(
-						"[v2Workspaces.onInsert] local sidebar state write failed; remote create succeeded",
-						{ workspaceId: result.workspace.id, err },
-					);
-				}
-
-				return result.txid !== undefined ? { txid: result.txid } : undefined;
-			},
 			onUpdate: async ({ transaction }) => {
 				const { original, changes } = transaction.mutations[0];
 				const { branch, hostId, name } = changes;
diff --git a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/index.ts b/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/index.ts
index 28138c82fdc..53b72976220 100644
--- a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/index.ts
+++ b/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/index.ts
@@ -1,3 +1,2 @@
 export * from "./schema";
 export * from "./sidebarVisibility";
-export * from "./tabOrder";
diff --git a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/tabOrder.ts b/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/tabOrder.ts
deleted file mode 100644
index c68a579ffd7..00000000000
--- a/apps/desktop/src/renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/tabOrder.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * Lower tabOrder = appears earlier in the sidebar (queries sort ASC).
- * Prepending therefore picks one less than the smallest existing tabOrder
- * so the new item lands at the top regardless of whether existing items
- * are positive (newly defaulted) or negative (after prior prepends).
- */
-export function getPrependTabOrder(items: Array<{ tabOrder: number }>): number {
-	if (items.length === 0) return 1;
-	const minTabOrder = items.reduce(
-		(minValue, item) => Math.min(minValue, item.tabOrder),
-		Number.POSITIVE_INFINITY,
-	);
-	return minTabOrder - 1;
-}
-
-export function getNextTabOrder(items: Array<{ tabOrder: number }>): number {
-	const maxTabOrder = items.reduce(
-		(maxValue, item) => Math.max(maxValue, item.tabOrder),
-		0,
-	);
-	return maxTabOrder + 1;
-}
diff --git a/apps/desktop/src/renderer/stores/workspace-creates/Manager.tsx b/apps/desktop/src/renderer/stores/workspace-creates/Manager.tsx
new file mode 100644
index 00000000000..34910a81670
--- /dev/null
+++ b/apps/desktop/src/renderer/stores/workspace-creates/Manager.tsx
@@ -0,0 +1,30 @@
+import { useLiveQuery } from "@tanstack/react-db";
+import { useEffect } from "react";
+import { useCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider";
+import { useWorkspaceCreatesStore } from "./store";
+
+export function WorkspaceCreatesManager() {
+	const collections = useCollections();
+	const { data: workspaces = [] } = useLiveQuery(
+		(q) =>
+			q.from({ ws: collections.v2Workspaces }).select(({ ws }) => ({
+				id: ws.id,
+			})),
+		[collections],
+	);
+	const entries = useWorkspaceCreatesStore((store) => store.entries);
+
+	useEffect(() => {
+		if (workspaces.length === 0 || entries.length === 0) return;
+		const realIds = new Set(workspaces.map((w) => w.id));
+		const remove = useWorkspaceCreatesStore.getState().remove;
+		for (const entry of entries) {
+			const id = entry.snapshot.id;
+			if (id && realIds.has(id)) {
+				remove(id);
+			}
+		}
+	}, [workspaces, entries]);
+
+	return null;
+}
diff --git a/apps/desktop/src/renderer/stores/workspace-creates/index.ts b/apps/desktop/src/renderer/stores/workspace-creates/index.ts
index 45cedfbd873..46bb1f440a4 100644
--- a/apps/desktop/src/renderer/stores/workspace-creates/index.ts
+++ b/apps/desktop/src/renderer/stores/workspace-creates/index.ts
@@ -1,10 +1,12 @@
+export { WorkspaceCreatesManager } from "./Manager";
 export {
-	type FailedWorkspaceCreate,
-	useWorkspaceCreateFailuresStore,
+	type InFlightEntry,
+	useWorkspaceCreatesStore,
 	type WorkspacesCreateInput,
 } from "./store";
 export {
 	type SubmitArgs,
 	type SubmitResult,
+	type UseWorkspaceCreatesApi,
 	useWorkspaceCreates,
 } from "./useWorkspaceCreates";
diff --git a/apps/desktop/src/renderer/stores/workspace-creates/store.ts b/apps/desktop/src/renderer/stores/workspace-creates/store.ts
index d8b9d0c0c03..3842407936f 100644
--- a/apps/desktop/src/renderer/stores/workspace-creates/store.ts
+++ b/apps/desktop/src/renderer/stores/workspace-creates/store.ts
@@ -5,67 +5,50 @@ import { create } from "zustand";
 export type WorkspacesCreateInput =
 	inferRouterInputs<AppRouter>["workspaces"]["create"];
 
-/**
- * Sidecar payload threaded through `collections.v2Workspaces.insert(row, { metadata })`
- * to the Electric `onInsert` handler. Carries the host-service URL plus the
- * `workspaces.create` arguments that don't live on the v2_workspaces row
- * (PR number, base branch, agent launches, original optional name/branch
- * before placeholder fallback).
- */
-export interface WorkspaceCreateMeta {
-	hostUrl: string;
-	providedName?: string;
-	providedBranch?: string;
-	pr?: number;
-	baseBranch?: string;
-	agents?: WorkspacesCreateInput["agents"];
-}
-
-/**
- * Thrown from `onInsert` when the host service returns an existing workspace
- * with a different id than the optimistic row. The renderer's submit hook
- * catches this to redirect/clean up; Electric uses the rejection to roll
- * back the optimistic insert.
- */
-export class WorkspaceAlreadyExistsAtDifferentIdError extends Error {
-	readonly canonicalWorkspaceId: string;
-	constructor(canonicalWorkspaceId: string) {
-		super(`Workspace already exists at different id: ${canonicalWorkspaceId}`);
-		this.name = "WorkspaceAlreadyExistsAtDifferentIdError";
-		this.canonicalWorkspaceId = canonicalWorkspaceId;
-	}
-}
-
-export interface FailedWorkspaceCreate {
+export interface InFlightEntry {
 	hostId: string;
 	snapshot: WorkspacesCreateInput;
-	error: string;
-	failedAt: number;
+	state: "creating" | "error";
+	error?: string;
+	startedAt: number;
 }
 
-interface WorkspaceCreateFailuresState {
-	failures: Record<string, FailedWorkspaceCreate>;
-	record: (workspaceId: string, entry: FailedWorkspaceCreate) => void;
-	clear: (workspaceId: string) => void;
+interface WorkspaceCreatesState {
+	entries: InFlightEntry[];
+	add: (entry: Omit<InFlightEntry, "startedAt">) => void;
+	markError: (workspaceId: string, error: string) => void;
+	markCreating: (workspaceId: string) => void;
+	remove: (workspaceId: string) => void;
 }
 
-/**
- * Persists workspace creates that rolled back so the user can retry from
- * the workspace detail page. Successes don't touch this store — the
- * optimistic row in `collections.v2Workspaces` carries `$synced=false`
- * while in flight, which is the loading signal everywhere else.
- */
-export const useWorkspaceCreateFailuresStore =
-	create<WorkspaceCreateFailuresState>((set) => ({
-		failures: {},
-		record: (workspaceId, entry) =>
+export const useWorkspaceCreatesStore = create<WorkspaceCreatesState>(
+	(set) => ({
+		entries: [],
+		add: (entry) =>
+			set((state) => ({
+				entries: [...state.entries, { ...entry, startedAt: Date.now() }],
+			})),
+		markError: (workspaceId, error) =>
+			set((state) => ({
+				entries: state.entries.map((entry) =>
+					entry.snapshot.id === workspaceId
+						? { ...entry, state: "error", error }
+						: entry,
+				),
+			})),
+		markCreating: (workspaceId) =>
+			set((state) => ({
+				entries: state.entries.map((entry) =>
+					entry.snapshot.id === workspaceId
+						? { ...entry, state: "creating", error: undefined }
+						: entry,
+				),
+			})),
+		remove: (workspaceId) =>
 			set((state) => ({
-				failures: { ...state.failures, [workspaceId]: entry },
+				entries: state.entries.filter(
+					(entry) => entry.snapshot.id !== workspaceId,
+				),
 			})),
-		clear: (workspaceId) =>
-			set((state) => {
-				if (!(workspaceId in state.failures)) return state;
-				const { [workspaceId]: _, ...rest } = state.failures;
-				return { failures: rest };
-			}),
-	}));
+	}),
+);
diff --git a/apps/desktop/src/renderer/stores/workspace-creates/useWorkspaceCreates.ts b/apps/desktop/src/renderer/stores/workspace-creates/useWorkspaceCreates.ts
index dd01cc08524..56b7cab247c 100644
--- a/apps/desktop/src/renderer/stores/workspace-creates/useWorkspaceCreates.ts
+++ b/apps/desktop/src/renderer/stores/workspace-creates/useWorkspaceCreates.ts
@@ -1,13 +1,15 @@
-import type { SelectV2Workspace } from "@superset/db/schema";
+import type { WorkspaceState } from "@superset/panes";
 import { useCallback } from "react";
 import { resolveHostUrl } from "renderer/hooks/host-service/useHostTargetUrl";
 import { authClient } from "renderer/lib/auth-client";
+import { getHostServiceClientByUrl } from "renderer/lib/host-service-client";
+import type { PaneViewerData } from "renderer/routes/_authenticated/_dashboard/v2-workspace/$workspaceId/types";
 import { useCollections } from "renderer/routes/_authenticated/providers/CollectionsProvider";
 import { useLocalHostService } from "renderer/routes/_authenticated/providers/LocalHostServiceProvider";
+import { appendLaunchesToPaneLayout } from "./appendLaunchesToPaneLayout";
 import {
-	useWorkspaceCreateFailuresStore,
-	WorkspaceAlreadyExistsAtDifferentIdError,
-	type WorkspaceCreateMeta,
+	type InFlightEntry,
+	useWorkspaceCreatesStore,
 	type WorkspacesCreateInput,
 } from "./store";
 
@@ -20,108 +22,137 @@ export type SubmitResult =
 	| { ok: true; workspaceId: string; alreadyExists: boolean }
 	| { ok: false; error: string };
 
-const PLACEHOLDER_WORKSPACE_NAME = "New workspace";
-
-function buildOptimisticRow(args: {
-	snapshot: WorkspacesCreateInput;
-	hostId: string;
-	organizationId: string;
-	currentUserId: string | null;
-	startedAt: number;
-}): SelectV2Workspace {
-	const { snapshot, hostId, organizationId, currentUserId, startedAt } = args;
-	const created = new Date(startedAt);
-	return {
-		id: snapshot.id as string,
-		organizationId,
-		projectId: snapshot.projectId,
-		hostId,
-		name: snapshot.name ?? PLACEHOLDER_WORKSPACE_NAME,
-		branch: snapshot.branch ?? snapshot.name ?? "",
-		type: "worktree",
-		createdByUserId: currentUserId,
-		taskId: snapshot.taskId ?? null,
-		createdAt: created,
-		updatedAt: created,
-	};
+export interface UseWorkspaceCreatesApi {
+	entries: InFlightEntry[];
+	submit: (args: SubmitArgs) => Promise<SubmitResult>;
+	retry: (workspaceId: string) => Promise<void>;
+	dismiss: (workspaceId: string) => void;
 }
 
-/**
- * Submits a v2 workspace.create as a tanstack-db optimistic insert against
- * `collections.v2Workspaces`. The handler in `collections.ts:onInsert` does
- * the host-service round-trip; this hook just builds the optimistic row +
- * metadata sidecar and translates the rollback into a failure record so the
- * detail page can offer retry.
- */
-export function useWorkspaceCreates(): {
-	submit: (args: SubmitArgs) => Promise<SubmitResult>;
-} {
+export function useWorkspaceCreates(): UseWorkspaceCreatesApi {
+	const entries = useWorkspaceCreatesStore((s) => s.entries);
 	const { machineId, activeHostUrl } = useLocalHostService();
 	const { data: session } = authClient.useSession();
 	const organizationId = session?.session?.activeOrganizationId;
-	const currentUserId = session?.user?.id ?? null;
 	const collections = useCollections();
 
-	const submit = useCallback(
+	const dispatch = useCallback(
 		async (args: SubmitArgs): Promise<SubmitResult> => {
 			const workspaceId = args.snapshot.id;
 			if (!workspaceId) {
 				throw new Error(
-					"workspaces.create requires `id` for optimistic insert",
+					"workspaces.create requires `id` for in-flight tracking",
 				);
 			}
+			if (!organizationId) {
+				const error = "No active organization";
+				useWorkspaceCreatesStore.getState().markError(workspaceId, error);
+				return { ok: false, error };
+			}
+			const hostUrl = resolveHostUrl({
+				hostId: args.hostId,
+				machineId,
+				activeHostUrl,
+				organizationId,
+			});
+			if (!hostUrl) {
+				const error = "Host service not available";
+				useWorkspaceCreatesStore.getState().markError(workspaceId, error);
+				return { ok: false, error };
+			}
 			try {
-				if (!organizationId) throw new Error("No active organization");
-				const hostUrl = resolveHostUrl({
-					hostId: args.hostId,
-					machineId,
-					activeHostUrl,
-					organizationId,
-				});
-				if (!hostUrl) throw new Error("Host service not available");
+				const client = getHostServiceClientByUrl(hostUrl);
+				const result = await client.workspaces.create.mutate(args.snapshot);
 
-				const meta: WorkspaceCreateMeta = {
-					hostUrl,
-					providedName: args.snapshot.name,
-					providedBranch: args.snapshot.branch,
-					pr: args.snapshot.pr,
-					baseBranch: args.snapshot.baseBranch,
-					agents: args.snapshot.agents,
-				};
-				const tx = collections.v2Workspaces.insert(
-					buildOptimisticRow({
-						snapshot: args.snapshot,
-						hostId: args.hostId,
-						organizationId,
-						currentUserId,
-						startedAt: Date.now(),
-					}),
-					{ metadata: meta as unknown as Record<string, unknown> },
+				const existing = collections.v2WorkspaceLocalState.get(
+					result.workspace.id,
 				);
-				await tx.isPersisted.promise;
-				useWorkspaceCreateFailuresStore.getState().clear(workspaceId);
-				return { ok: true, workspaceId, alreadyExists: false };
-			} catch (err) {
-				if (err instanceof WorkspaceAlreadyExistsAtDifferentIdError) {
-					useWorkspaceCreateFailuresStore.getState().clear(workspaceId);
-					return {
-						ok: true,
-						workspaceId: err.canonicalWorkspaceId,
-						alreadyExists: true,
-					};
+				const paneLayout = appendLaunchesToPaneLayout({
+					existing: existing?.paneLayout as
+						| WorkspaceState<PaneViewerData>
+						| undefined,
+					terminals: result.terminals,
+					agents: result.agents,
+				});
+				if (existing) {
+					collections.v2WorkspaceLocalState.update(
+						result.workspace.id,
+						(draft) => {
+							draft.paneLayout = paneLayout;
+						},
+					);
+				} else {
+					collections.v2WorkspaceLocalState.insert({
+						workspaceId: result.workspace.id,
+						createdAt: new Date(),
+						sidebarState: {
+							projectId: result.workspace.projectId,
+							tabOrder: 0,
+							sectionId: null,
+							changesFilter: { kind: "all" },
+							activeTab: "changes",
+							isHidden: false,
+						},
+						paneLayout,
+						viewedFiles: [],
+						recentlyViewedFiles: [],
+					});
 				}
+				// On alreadyExists the server returns the canonical workspace id,
+				// which can differ from our optimistic snapshot id. The in-flight
+				// entry is still keyed by snapshot id and won't ever resolve, so
+				// drop it — the canonical workspace now lives in collections and
+				// callers redirect there.
+				if (result.alreadyExists && result.workspace.id !== workspaceId) {
+					useWorkspaceCreatesStore.getState().remove(workspaceId);
+				}
+				return {
+					ok: true,
+					workspaceId: result.workspace.id,
+					alreadyExists: result.alreadyExists,
+				};
+			} catch (err) {
 				const error = err instanceof Error ? err.message : String(err);
-				useWorkspaceCreateFailuresStore.getState().record(workspaceId, {
-					hostId: args.hostId,
-					snapshot: args.snapshot,
-					error,
-					failedAt: Date.now(),
-				});
+				useWorkspaceCreatesStore.getState().markError(workspaceId, error);
 				return { ok: false, error };
 			}
 		},
-		[machineId, activeHostUrl, organizationId, currentUserId, collections],
+		[machineId, activeHostUrl, organizationId, collections],
+	);
+
+	const submit = useCallback(
+		async (args: SubmitArgs): Promise<SubmitResult> => {
+			const workspaceId = args.snapshot.id;
+			if (!workspaceId) {
+				throw new Error(
+					"workspaces.create requires `id` for in-flight tracking",
+				);
+			}
+			useWorkspaceCreatesStore.getState().add({
+				hostId: args.hostId,
+				snapshot: args.snapshot,
+				state: "creating",
+			});
+			return await dispatch(args);
+		},
+		[dispatch],
 	);
 
-	return { submit };
+	const retry = useCallback(
+		async (workspaceId: string) => {
+			const entry = useWorkspaceCreatesStore
+				.getState()
+				.entries.find((e) => e.snapshot.id === workspaceId);
+			if (!entry) return;
+			useWorkspaceCreatesStore.getState().markCreating(workspaceId);
+			await dispatch({ hostId: entry.hostId, snapshot: entry.snapshot });
+		},
+		[dispatch],
+	);
+
+	const dismiss = useCallback((workspaceId: string) => {
+		useWorkspaceCreatesStore.getState().remove(workspaceId);
+	}, []);
+
+	return { entries, submit, retry, dismiss };
 }
diff --git a/packages/host-service/src/trpc/router/workspace-creation/shared/adopt-existing-worktree.ts b/packages/host-service/src/trpc/router/workspace-creation/shared/adopt-existing-worktree.ts
index 5054626ec1d..8b898047423 100644
--- a/packages/host-service/src/trpc/router/workspace-creation/shared/adopt-existing-worktree.ts
+++ b/packages/host-service/src/trpc/router/workspace-creation/shared/adopt-existing-worktree.ts
@@ -34,10 +34,6 @@ export interface AdoptExistingWorktreeResult {
 	 *  created in this call. Used by `workspaces.create` to decide whether
 	 *  to dispatch setup terminal + sugar agents. */
 	alreadyExists: boolean;
-	/** Postgres xid of the API insert when this call freshly created the
-	 *  cloud row. Undefined for reuse paths so renderer optimistic inserts
-	 *  fall back to natural shape sync. */
-	txid?: number;
 }
 
 /**
@@ -221,7 +217,6 @@ export async function adoptExistingWorktree(
 	return {
 		workspace: cloudRow,
 		alreadyExists: false,
-		txid: cloudRow.txid,
 	};
 }
 
diff --git a/packages/host-service/src/trpc/router/workspaces/workspaces.ts b/packages/host-service/src/trpc/router/workspaces/workspaces.ts
index bab519e00c7..ae2db7c5782 100644
--- a/packages/host-service/src/trpc/router/workspaces/workspaces.ts
+++ b/packages/host-service/src/trpc/router/workspaces/workspaces.ts
@@ -381,13 +381,7 @@ async function registerCloudAndLocal(args: {
 	taskId: string | undefined;
 	rollbackWorktree: () => Promise<void>;
 	hostPromise: Promise<{ machineId: string }>;
-}): Promise<{
-	id: string;
-	projectId: string;
-	name: string;
-	branch: string;
-	txid?: number;
-}> {
+}): Promise<{ id: string; projectId: string; name: string; branch: string }> {
 	const { ctx } = args;
 	let host: { machineId: string };
 	try {
@@ -454,7 +448,6 @@ async function registerCloudAndLocal(args: {
 		projectId: cloudRow.projectId,
 		name: cloudRow.name,
 		branch: cloudRow.branch,
-		txid: cloudRow.txid,
 	};
 }
 
@@ -538,12 +531,7 @@ export const workspacesRouter = router({
 				projectId: string;
 				name: string;
 				branch: string;
-				txid?: number;
 			};
-			// Postgres xid of the cloud insert in this call. Set on fresh-create
-			// paths and bubbled up to renderer optimistic inserts so Electric can
-			// match the synced row.
-			let workspaceTxid: number | undefined;
 			let prMetadata: PrMetadata | null = null;
 
 			if (input.pr !== undefined) {
@@ -601,7 +589,6 @@ export const workspacesRouter = router({
 						});
 						workspaceRow = result.workspace;
 						alreadyExists = result.alreadyExists;
-						workspaceTxid = result.txid;
 						await enablePushAutoSetupRemote(
 							git,
 							worktreePath,
@@ -714,7 +701,6 @@ export const workspacesRouter = router({
 							rollbackWorktree,
 							hostPromise,
 						});
-						workspaceTxid = workspaceRow.txid;
 
 						if (prMetadata.baseRefName) {
 							await recordBaseBranchConfig({
@@ -800,7 +786,6 @@ export const workspacesRouter = router({
 						});
 						workspaceRow = result.workspace;
 						alreadyExists = result.alreadyExists;
-						workspaceTxid = result.txid;
 					} else {
 						worktreePath = safeResolveWorktreePath(
 							localProject.id,
@@ -858,7 +843,6 @@ export const workspacesRouter = router({
 							rollbackWorktree,
 							hostPromise,
 						});
-						workspaceTxid = workspaceRow.txid;
 					}
 				}
 			}
@@ -897,10 +881,6 @@ export const workspacesRouter = router({
 				terminals: terminalsResult,
 				agents: agentsResult,
 				alreadyExists,
-				// Postgres xid set when this call freshly created the cloud row.
-				// Renderers thread it back to Electric so optimistic inserts
-				// resolve against the synced shape.
-				txid: workspaceTxid,
 			};
 		}),
 
diff --git a/packages/trpc/src/router/v2-workspace/v2-workspace.ts b/packages/trpc/src/router/v2-workspace/v2-workspace.ts
index d14a05ec157..f8e3f9c3e3a 100644
--- a/packages/trpc/src/router/v2-workspace/v2-workspace.ts
+++ b/packages/trpc/src/router/v2-workspace/v2-workspace.ts
@@ -238,8 +238,7 @@ export const v2WorkspaceRouter = {
 							type: inserted.type,
 						},
 					});
-					const txid = await getCurrentTxid(tx);
-					return { row: inserted, txid };
+					return inserted;
 				}
 
 				if (input.id) {
@@ -249,9 +248,7 @@ export const v2WorkspaceRouter = {
 							eq(v2Workspaces.organizationId, project.organizationId),
 						),
 					});
-					if (existing) {
-						return { row: existing, txid: undefined };
-					}
+					if (existing) return existing;
 					const collision = await tx.query.v2Workspaces.findFirst({
 						columns: { id: true },
 						where: eq(v2Workspaces.id, input.id),
@@ -289,23 +286,16 @@ export const v2WorkspaceRouter = {
 								.set(patch)
 								.where(eq(v2Workspaces.id, existing.id))
 								.returning();
-							const txid = await getCurrentTxid(tx);
-							return { row: updated ?? existing, txid };
+							return updated ?? existing;
 						}
-						return { row: existing, txid: undefined };
+						return existing;
 					}
 				}
 
 				return null;
 			});
 
-			if (result) {
-				// `txid` is undefined on idempotent return paths where the row was
-				// already synced; renderer optimistic inserts treat that as
-				// "accept without waiting" and let the natural shape stream
-				// settle the state.
-				return { ...result.row, txid: result.txid };
-			}
+			if (result) return result;
 
 			throw new TRPCError({
 				code: "INTERNAL_SERVER_ERROR",