diff --git a/Cargo.lock b/Cargo.lock
index 36e2b166b5..a737b326d0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2760,6 +2760,7 @@ version = "0.0.0"
 dependencies = [
  "bstr",
  "git2",
+ "gitbutler-oxidize",
  "gix",
  "serde",
 ]
@@ -2791,6 +2792,7 @@ dependencies = [
  "gitbutler-fs",
  "gitbutler-git",
  "gitbutler-id",
+ "gitbutler-oxidize",
  "gitbutler-reference",
  "gitbutler-repo",
  "gitbutler-repo-actions",
@@ -2804,6 +2806,7 @@ dependencies = [
  "tempfile",
  "toml 0.8.19",
  "tracing",
+ "uuid",
 ]
 
 [[package]]
@@ -2824,11 +2827,13 @@ dependencies = [
  "gitbutler-error",
  "gitbutler-id",
  "gitbutler-oplog",
+ "gitbutler-oxidize",
  "gitbutler-project",
  "gitbutler-reference",
  "gitbutler-stack",
  "gitbutler-url",
  "gitbutler-user",
+ "gix",
  "itertools 0.14.0",
  "tracing",
 ]
diff --git a/apps/desktop/src/lib/backend/projectCloudSync.svelte.ts b/apps/desktop/src/lib/backend/projectCloudSync.svelte.ts
index 044a61df2b..38b35ee2a1 100644
--- a/apps/desktop/src/lib/backend/projectCloudSync.svelte.ts
+++ b/apps/desktop/src/lib/backend/projectCloudSync.svelte.ts
@@ -1,5 +1,4 @@
-import { registerInterest } from '@gitbutler/shared/interest/registerInterestFunction.svelte';
-import { projectsSelectors } from '@gitbutler/shared/organizations/projectsSlice';
+import { getProjectByRepositoryId } from '@gitbutler/shared/organizations/projectsPreview.svelte';
 import { readableToReactive } from '@gitbutler/shared/reactiveUtils.svelte';
 import type { ProjectService, ProjectsService } from '$lib/backend/projects';
 import type { HttpClient } from '@gitbutler/shared/network/httpClient';
@@ -16,26 +15,21 @@ export function projectCloudSync(
 	const project = readableToReactive(projectService.project);
 	const authentictionAvailable = readableToReactive(httpClient.authenticationAvailable);
 
-	$effect(() => {
-		if (!project.current?.api || !authentictionAvailable) return;
-
-		const cloudProjectInterest = cloudProjectService.getProjectInterest(
-			project.current.api.repository_id
-		);
-		registerInterest(cloudProjectInterest);
-	});
-
 	const loadableCloudProject = $derived(
-		project.current?.api
-			? projectsSelectors.selectById(appState.projects, project.current.api.repository_id)
+		project.current?.api && authentictionAvailable
+			? getProjectByRepositoryId(appState, cloudProjectService, project.current.api.repository_id)
 			: undefined
 	);
 
 	$effect(() => {
-		if (!project.current?.api || !loadableCloudProject || loadableCloudProject.status !== 'found')
+		if (
+			!project.current?.api ||
+			!loadableCloudProject?.current ||
+			loadableCloudProject?.current.status !== 'found'
+		)
 			return;
 
-		const cloudProject = loadableCloudProject.value;
+		const cloudProject = loadableCloudProject.current.value;
 		const persistedProjectUpdatedAt = new Date(project.current.api.updated_at).getTime();
 		const cloudProjectUpdatedAt = new Date(cloudProject.updatedAt).getTime();
 		if (persistedProjectUpdatedAt >= cloudProjectUpdatedAt) return;
diff --git a/apps/desktop/src/lib/branch/SeriesHeader.svelte b/apps/desktop/src/lib/branch/SeriesHeader.svelte
index e7ff547138..32f890612d 100644
--- a/apps/desktop/src/lib/branch/SeriesHeader.svelte
+++ b/apps/desktop/src/lib/branch/SeriesHeader.svelte
@@ -10,10 +10,8 @@
 	import { Project } from '$lib/backend/projects';
 	import { BaseBranch } from '$lib/baseBranch/baseBranch';
 	import SeriesHeaderContextMenu from '$lib/branch/SeriesHeaderContextMenu.svelte';
-	import { CloudBranchCreationService } from '$lib/branch/cloudBranchCreationService';
 	import ContextMenu from '$lib/components/contextmenu/ContextMenu.svelte';
 	import { projectAiGenEnabled } from '$lib/config/config';
-	import { cloudReviewFunctionality } from '$lib/config/uiFeatureFlags';
 	import { getForge } from '$lib/forge/interface/forge';
 	import { getForgeListingService } from '$lib/forge/interface/forgeListingService';
 	import { getForgePrService } from '$lib/forge/interface/forgePrService';
@@ -145,11 +143,6 @@
 		await Promise.allSettled([prMonitor?.refresh(), checksMonitor?.update()]);
 	}
 
-	const cloudBranchCreationService = getContext(CloudBranchCreationService);
-	const showCreateCloudBranch = $derived(
-		$cloudReviewFunctionality && cloudBranchCreationService.canCreateBranch
-	);
-
 	/**
 	 * We are starting to store pull request id's locally so if we find one that does not have
 	 * one locally stored then we set it once.
@@ -377,7 +370,7 @@
 				{/if}
 			</div>
 		</div>
-		{#if ($prService && !hasNoCommits) || showCreateCloudBranch}
+		{#if $prService && !hasNoCommits}
 			<div class="branch-action">
 				<div class="branch-action__line" style:--bg-color={lineColor}></div>
 				<div class="branch-action__body">
@@ -417,17 +410,6 @@
 							</Button>
 						{/if}
 					{/if}
-
-					{#if showCreateCloudBranch}
-						<Button
-							style="ghost"
-							outline
-							disabled={branch.patches.length === 0}
-							onclick={() => {
-								cloudBranchCreationService.createBranch(stack.id);
-							}}>Publish Branch</Button
-						>
-					{/if}
 				</div>
 			</div>
 		{/if}
diff --git a/apps/desktop/src/lib/branch/cloudBranchCreationService.ts b/apps/desktop/src/lib/branch/cloudBranchCreationService.ts
deleted file mode 100644
index 8a552a0fc6..0000000000
--- a/apps/desktop/src/lib/branch/cloudBranchCreationService.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { derived, type Readable } from 'svelte/store';
-import type { SyncedSnapshotService } from '$lib/history/syncedSnapshotService';
-
-/**
- * This service is responsible for integrating the client side oplog
- * manipulation with actual cloud patch stack creation.
- */
-export class CloudBranchCreationService {
-	canCreateBranch: Readable<boolean>;
-
-	constructor(
-		private readonly syncedSnapshotService: SyncedSnapshotService
-		// private readonly cloudBranchesService: CloudBranchesService
-	) {
-		this.canCreateBranch = derived(
-			[this.syncedSnapshotService.canTakeSnapshot],
-			([canTakeSnapshot]) => {
-				return canTakeSnapshot;
-			}
-		);
-	}
-
-	async createBranch(_branchId: string): Promise<void> {
-		const _oplogSha = await this.syncedSnapshotService.takeSyncedSnapshot();
-		// const cloudBranch = await this.cloudBranchesService.createBranch(branchId, oplogSha);
-		// return cloudBranch;
-	}
-}
diff --git a/apps/desktop/src/lib/history/stackPublishingService.ts b/apps/desktop/src/lib/history/stackPublishingService.ts
new file mode 100644
index 0000000000..00c9b7ae46
--- /dev/null
+++ b/apps/desktop/src/lib/history/stackPublishingService.ts
@@ -0,0 +1,51 @@
+import { CommandService } from '$lib/backend/ipc';
+import { derived, get, type Readable } from 'svelte/store';
+import type { Project } from '$lib/backend/projects';
+import type { User } from '$lib/stores/user';
+
+export class StackPublishingService {
+	/**
+	 * Signal for the frontend to choose whether or not to provide the
+	 * takeSyncedSnapshot button.
+	 */
+	canPublish: Readable<boolean>;
+
+	#joinedUserAndProject: Readable<{
+		user: User | undefined;
+		project: Project | undefined;
+	}>;
+
+	constructor(
+		private readonly commandService: CommandService,
+		private readonly user: Readable<User | undefined>,
+		private readonly project: Readable<Project | undefined>
+	) {
+		this.#joinedUserAndProject = derived([this.user, this.project], ([user, project]) => {
+			return { user, project };
+		});
+
+		this.canPublish = derived(this.#joinedUserAndProject, ({ user, project }) => {
+			return this.canTakeSnapshotGivenUserAndProject(user, project);
+		});
+	}
+
+	async upsertStack(stackId?: string): Promise<void> {
+		// Take a snapshot
+		const { user, project } = get(this.#joinedUserAndProject);
+
+		// Project and user are now defined
+		if (!this.canTakeSnapshotGivenUserAndProject(user, project)) {
+			throw new Error('Cannot publish branch');
+		}
+
+		await this.commandService.invoke<string>('push_stack_to_review', {
+			projectId: project!.id,
+			user: user!,
+			stackId
+		});
+	}
+
+	private canTakeSnapshotGivenUserAndProject(user: User | undefined, project: Project | undefined) {
+		return user !== undefined && !!project?.api?.sync;
+	}
+}
diff --git a/apps/desktop/src/lib/settings/userPreferences/CloudProjectSettings.svelte b/apps/desktop/src/lib/settings/userPreferences/CloudProjectSettings.svelte
index c7094b547a..e6ab14b163 100644
--- a/apps/desktop/src/lib/settings/userPreferences/CloudProjectSettings.svelte
+++ b/apps/desktop/src/lib/settings/userPreferences/CloudProjectSettings.svelte
@@ -141,40 +141,42 @@
 
 	<Loading loadable={cloudProject}>
 		{#snippet children(cloudProject)}
-			<Section>
-				{#snippet title()}
-					Link your project with an organization
-				{/snippet}
-
-				<RegisterInterest interest={usersOrganizationsInterest} />
-
-				<div>
-					{#each usersOrganizations as loadableOrganization, index}
-						<SectionCard
-							roundedBottom={index === usersOrganizations.length - 1}
-							roundedTop={index === 0}
-							orientation="row"
-							centerAlign
-						>
-							{#snippet children()}
-								<Loading loadable={loadableOrganization}>
-									{#snippet children(organization)}
-										<h5 class="text-15 text-bold flex-grow">
-											{organization.name || organization.slug}
-										</h5>
-									{/snippet}
-								</Loading>
-							{/snippet}
-							{#snippet actions()}
-								<ProjectConnectModal
-									organizationSlug={loadableOrganization.id}
-									projectRepositoryId={cloudProject.repositoryId}
-								/>
-							{/snippet}
-						</SectionCard>
-					{/each}
-				</div>
-			</Section>
+			{#if !cloudProject.parentProjectRepositoryId}
+				<Section>
+					{#snippet title()}
+						Link your project with an organization
+					{/snippet}
+
+					<RegisterInterest interest={usersOrganizationsInterest} />
+
+					<div>
+						{#each usersOrganizations as loadableOrganization, index}
+							<SectionCard
+								roundedBottom={index === usersOrganizations.length - 1}
+								roundedTop={index === 0}
+								orientation="row"
+								centerAlign
+							>
+								{#snippet children()}
+									<Loading loadable={loadableOrganization}>
+										{#snippet children(organization)}
+											<h5 class="text-15 text-bold flex-grow">
+												{organization.name || organization.slug}
+											</h5>
+										{/snippet}
+									</Loading>
+								{/snippet}
+								{#snippet actions()}
+									<ProjectConnectModal
+										organizationSlug={loadableOrganization.id}
+										projectRepositoryId={cloudProject.repositoryId}
+									/>
+								{/snippet}
+							</SectionCard>
+						{/each}
+					</div>
+				</Section>
+			{/if}
 		{/snippet}
 	</Loading>
 {:else if !$project?.api?.repository_id}
diff --git a/apps/desktop/src/lib/stack/header/StackHeader.svelte b/apps/desktop/src/lib/stack/header/StackHeader.svelte
index 1cfbe61517..f41877a201 100644
--- a/apps/desktop/src/lib/stack/header/StackHeader.svelte
+++ b/apps/desktop/src/lib/stack/header/StackHeader.svelte
@@ -1,9 +1,12 @@
 <script lang="ts">
 	import HeaderControlSection from './HeaderControlSection.svelte';
 	import HeaderMetaSection from './HeaderMetaSection.svelte';
+	import { cloudReviewFunctionality } from '$lib/config/uiFeatureFlags';
+	import { StackPublishingService } from '$lib/history/stackPublishingService';
 	import { BranchController } from '$lib/vbranches/branchController';
 	import { BranchStack } from '$lib/vbranches/types';
 	import { getContext } from '@gitbutler/shared/context';
+	import Button from '@gitbutler/ui/Button.svelte';
 	import { isError } from '@gitbutler/ui/utils/typeguards';
 
 	interface Props {
@@ -13,25 +16,38 @@
 
 	const branchController = getContext(BranchController);
 
-	const { onCollapseButtonClick, stack: branch }: Props = $props();
+	const { onCollapseButtonClick, stack }: Props = $props();
 
 	const nonArchivedSeries = $derived(
-		branch.series.filter((s) => {
+		stack.series.filter((s) => {
 			if (isError(s)) return s;
 			return !s.archived;
 		})
 	);
+
+	const stackPublishingService = getContext(StackPublishingService);
+	const canPublish = stackPublishingService.canPublish;
+	let publishing = $state<'inert' | 'loading' | 'complete'>('inert');
+
+	async function publishStack() {
+		publishing = 'loading';
+		await stackPublishingService.upsertStack(stack.id);
+		publishing = 'complete';
+	}
 </script>
 
 <div class="stack-header">
 	<HeaderControlSection
-		isDefault={branch.selectedForChanges}
+		isDefault={stack.selectedForChanges}
 		{onCollapseButtonClick}
 		onDefaultSet={async () => {
-			await branchController.setSelectedForChanges(branch.id);
+			await branchController.setSelectedForChanges(stack.id);
 		}}
 	/>
 	<HeaderMetaSection series={nonArchivedSeries} {onCollapseButtonClick} />
+	{#if $cloudReviewFunctionality && $canPublish}
+		<Button onclick={publishStack} loading={publishing === 'loading'}>Publish stack</Button>
+	{/if}
 </div>
 
 <style lang="postcss">
diff --git a/apps/desktop/src/routes/[projectId]/+layout.svelte b/apps/desktop/src/routes/[projectId]/+layout.svelte
index 936ecd17bb..524c2abca5 100644
--- a/apps/desktop/src/routes/[projectId]/+layout.svelte
+++ b/apps/desktop/src/routes/[projectId]/+layout.svelte
@@ -6,7 +6,6 @@
 	import ProjectSettingsMenuAction from '$lib/barmenuActions/ProjectSettingsMenuAction.svelte';
 	import { BaseBranch, NoDefaultTarget } from '$lib/baseBranch/baseBranch';
 	import { BaseBranchService } from '$lib/baseBranch/baseBranchService';
-	import { CloudBranchCreationService } from '$lib/branch/cloudBranchCreationService';
 	import { BranchListingService, CombinedBranchListingService } from '$lib/branches/branchListing';
 	import { BranchDragActionsFactory } from '$lib/branches/dragActions';
 	import { GitBranchService } from '$lib/branches/gitBranch';
@@ -27,6 +26,7 @@
 	import { createForgeRepoServiceStore } from '$lib/forge/interface/forgeRepoService';
 	import History from '$lib/history/History.svelte';
 	import { HistoryService } from '$lib/history/history';
+	import { StackPublishingService } from '$lib/history/stackPublishingService';
 	import { SyncedSnapshotService } from '$lib/history/syncedSnapshotService';
 	import { ModeService } from '$lib/modes/service';
 	import Navigation from '$lib/navigation/Navigation.svelte';
@@ -91,7 +91,7 @@
 
 		// Cloud related services
 		setContext(SyncedSnapshotService, data.syncedSnapshotService);
-		setContext(CloudBranchCreationService, data.cloudBranchCreationService);
+		setContext(StackPublishingService, data.stackPublishingService);
 		setContext(FileService, data.fileService);
 	});
 
diff --git a/apps/desktop/src/routes/[projectId]/+layout.ts b/apps/desktop/src/routes/[projectId]/+layout.ts
index 1cc9f50ecc..4613f1bf41 100644
--- a/apps/desktop/src/routes/[projectId]/+layout.ts
+++ b/apps/desktop/src/routes/[projectId]/+layout.ts
@@ -2,7 +2,6 @@ import { getUserErrorCode, invoke } from '$lib/backend/ipc';
 import { ProjectService, type Project } from '$lib/backend/projects';
 import { TemplateService } from '$lib/backend/templateService';
 import { BaseBranchService } from '$lib/baseBranch/baseBranchService';
-import { CloudBranchCreationService } from '$lib/branch/cloudBranchCreationService';
 import { BranchListingService } from '$lib/branches/branchListing';
 import { BranchDragActionsFactory } from '$lib/branches/dragActions.js';
 import { GitBranchService } from '$lib/branches/gitBranch';
@@ -11,6 +10,7 @@ import { CommitService } from '$lib/commits/service';
 import { StackingReorderDropzoneManagerFactory } from '$lib/dragging/stackingReorderDropzoneManager';
 import { FetchSignal } from '$lib/fetchSignal/fetchSignal.js';
 import { HistoryService } from '$lib/history/history';
+import { StackPublishingService } from '$lib/history/stackPublishingService';
 import { SyncedSnapshotService } from '$lib/history/syncedSnapshotService';
 import { ProjectMetrics } from '$lib/metrics/projectMetrics';
 import { ModeService } from '$lib/modes/service';
@@ -90,7 +90,11 @@ export const load: LayoutLoad = async ({ params, parent }) => {
 		userService.user,
 		projectsService.getProjectStore(projectId)
 	);
-	const cloudBranchCreationService = new CloudBranchCreationService(syncedSnapshotService);
+	const stackPublishingService = new StackPublishingService(
+		commandService,
+		userService.user,
+		projectsService.getProjectStore(projectId)
+	);
 
 	return {
 		authService,
@@ -118,6 +122,6 @@ export const load: LayoutLoad = async ({ params, parent }) => {
 
 		// Cloud-related services
 		syncedSnapshotService,
-		cloudBranchCreationService
+		stackPublishingService
 	};
 };
diff --git a/apps/desktop/src/routes/[projectId]/series/+page.svelte b/apps/desktop/src/routes/[projectId]/series/+page.svelte
index 66511682c7..3838ddd82d 100644
--- a/apps/desktop/src/routes/[projectId]/series/+page.svelte
+++ b/apps/desktop/src/routes/[projectId]/series/+page.svelte
@@ -1,8 +1,38 @@
 <script lang="ts">
+	import { ProjectService } from '$lib/backend/projects';
+	import { BranchService } from '@gitbutler/shared/branches/branchService';
+	import { getBranchReviews } from '@gitbutler/shared/branches/branchesPreview.svelte';
+	import { getContext } from '@gitbutler/shared/context';
+	import Loading from '@gitbutler/shared/network/Loading.svelte';
+	import { readableToReactive } from '@gitbutler/shared/reactiveUtils.svelte';
+	import { AppState } from '@gitbutler/shared/redux/store.svelte';
+
+	const appState = getContext(AppState);
+	const branchService = getContext(BranchService);
+	const projectService = getContext(ProjectService);
+
+	const project = readableToReactive(projectService.project);
+	const repositoryId = $derived(project.current?.api?.repository_id);
+
+	const branchReviews = $derived(
+		repositoryId ? getBranchReviews(appState, branchService, repositoryId) : undefined
+	);
 </script>
 
 <div class="series-container">
 	<h2 class="text-head-24 heading">Your branches:</h2>
+
+	{#if branchReviews?.current}
+		{#each branchReviews.current as review}
+			<Loading loadable={review}>
+				{#snippet children(review)}
+					<div>
+						<p>{review.title}</p>
+					</div>
+				{/snippet}
+			</Loading>
+		{/each}
+	{/if}
 </div>
 
 <style lang="postcss">
diff --git a/crates/gitbutler-branch-actions/Cargo.toml b/crates/gitbutler-branch-actions/Cargo.toml
index 8683c64331..7a09153848 100644
--- a/crates/gitbutler-branch-actions/Cargo.toml
+++ b/crates/gitbutler-branch-actions/Cargo.toml
@@ -46,6 +46,7 @@ gitbutler-project.workspace = true
 urlencoding = "2.1.3"
 reqwest = { version = "0.12.9", features = ["json"] }
 toml.workspace = true
+uuid.workspace = true
 
 [dev-dependencies]
 once_cell = "1.20"
diff --git a/crates/gitbutler-branch-actions/src/stack.rs b/crates/gitbutler-branch-actions/src/stack.rs
index 5303bc0ad6..6a53065efb 100644
--- a/crates/gitbutler-branch-actions/src/stack.rs
+++ b/crates/gitbutler-branch-actions/src/stack.rs
@@ -51,6 +51,7 @@ pub fn create_series(project: &Project, stack_id: StackId, req: CreateSeriesRequ
                 description: req.description,
                 pr_number: Default::default(),
                 archived: Default::default(),
+                review_id: uuid::Uuid::new_v4().to_string(),
             },
             req.preceding_head,
         )
diff --git a/crates/gitbutler-oplog/src/lib.rs b/crates/gitbutler-oplog/src/lib.rs
index 0322b02657..a2da0d80d8 100644
--- a/crates/gitbutler-oplog/src/lib.rs
+++ b/crates/gitbutler-oplog/src/lib.rs
@@ -1,7 +1,7 @@
 pub mod entry;
 mod oplog;
 pub use oplog::OplogExt;
-mod reflog;
+pub mod reflog;
 mod snapshot;
 pub use snapshot::SnapshotExt;
 mod state;
diff --git a/crates/gitbutler-oplog/src/oplog.rs b/crates/gitbutler-oplog/src/oplog.rs
index 83b5fafd99..8a7fb8f17a 100644
--- a/crates/gitbutler-oplog/src/oplog.rs
+++ b/crates/gitbutler-oplog/src/oplog.rs
@@ -6,6 +6,8 @@ use std::{
     time::Duration,
 };
 
+use crate::reflog::ReflogCommits;
+
 use super::{
     entry::{OperationKind, Snapshot, SnapshotDetails, Trailer},
     reflog::set_reference_to_oplog,
@@ -507,9 +509,7 @@ fn commit_snapshot(
 
     oplog_state.set_oplog_head(snapshot_commit_id)?;
 
-    let vb_state = VirtualBranchesHandle::new(ctx.gb_dir());
-    let target_commit_id = vb_state.get_default_target()?.sha;
-    set_reference_to_oplog(&ctx.path, target_commit_id, snapshot_commit_id)?;
+    set_reference_to_oplog(&ctx.path, ReflogCommits::new(ctx)?)?;
 
     Ok(snapshot_commit_id)
 }
diff --git a/crates/gitbutler-oplog/src/reflog.rs b/crates/gitbutler-oplog/src/reflog.rs
index a28787fc39..fc0cb95bf7 100644
--- a/crates/gitbutler-oplog/src/reflog.rs
+++ b/crates/gitbutler-oplog/src/reflog.rs
@@ -3,9 +3,40 @@ use std::path::Path;
 use anyhow::Result;
 use gitbutler_fs::write;
 use gitbutler_oxidize::OidExt as _;
+use gitbutler_project::Project;
 use gitbutler_repo::{GITBUTLER_COMMIT_AUTHOR_EMAIL, GITBUTLER_COMMIT_AUTHOR_NAME};
+use gitbutler_stack::VirtualBranchesHandle;
 use gix::config::tree::Key;
 
+use crate::state::OplogHandle;
+
+/// A collection of commits that we want to protect from `git GC`.
+///
+/// It can easily be produced from a [`Project`] to get the status quo to update the reflog after the project changed.
+#[derive(Debug, Clone, Copy)]
+pub struct ReflogCommits {
+    target: gix::ObjectId,
+    oplog: Option<gix::ObjectId>,
+    last_pushed_base: Option<gix::ObjectId>,
+}
+
+impl ReflogCommits {
+    /// Collect the current state of all relevant commits that we want to protect in the reflog to prevent them from being GC'd.
+    pub fn new(project: &Project) -> Result<Self> {
+        let vb_state = VirtualBranchesHandle::new(project.gb_dir());
+        let target = vb_state.get_default_target()?.sha.to_gix();
+        let last_pushed_base = vb_state.last_pushed_base()?;
+        let oplog_state = OplogHandle::new(&project.path);
+        let oplog = oplog_state.oplog_head()?.map(|commit| commit.to_gix());
+
+        Ok(ReflogCommits {
+            target,
+            oplog,
+            last_pushed_base,
+        })
+    }
+}
+
 /// Sets a reference to the oplog head commit such that snapshots are reachable and will not be garbage collected.
 /// We want to achieve 2 things:
 ///  - The oplog must not be visible in `git log --all` as branch
@@ -23,11 +54,7 @@ use gix::config::tree::Key;
 /// <target branch head>                     <oplog head>
 ///
 /// The reflog entry is continuously updated to refer to the current target and oplog head commits.
-pub(super) fn set_reference_to_oplog(
-    worktree_dir: &Path,
-    target_commit_id: git2::Oid,
-    oplog_commit_id: git2::Oid,
-) -> Result<()> {
+pub fn set_reference_to_oplog(worktree_dir: &Path, reflog_commits: ReflogCommits) -> Result<()> {
     let reflog_file_path = worktree_dir
         .join(".git")
         .join("logs")
@@ -50,7 +77,7 @@ pub(super) fn set_reference_to_oplog(
     // The check is here only to avoid unnecessary writes
     if repo.try_find_reference("gitbutler/target")?.is_none() {
         repo.refs.write_reflog = gix::refs::store::WriteReflog::Always;
-        let target_commit_hex = target_commit_id.to_string();
+        let target_commit_hex = reflog_commits.target.to_string();
         repo.reference(
             "refs/heads/gitbutler/target",
             target_commit_hex.parse::<gix::ObjectId>()?,
@@ -59,7 +86,16 @@ pub(super) fn set_reference_to_oplog(
         )?;
     }
 
-    let content = build_reflog_content(&[target_commit_id.to_gix(), oplog_commit_id.to_gix()]);
+    let content = build_reflog_content(
+        &[
+            Some(reflog_commits.target),
+            reflog_commits.oplog,
+            reflog_commits.last_pushed_base,
+        ]
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>(),
+    );
     write(reflog_file_path, content)?;
 
     Ok(())
@@ -127,12 +163,14 @@ fn serialize_line(line: gix::refs::file::log::LineRef<'_>) -> String {
 mod set_target_ref {
     use std::path::PathBuf;
 
+    use gitbutler_oxidize::OidExt;
     use gix::refs::file::log::LineRef;
     use pretty_assertions::assert_eq;
     use tempfile::tempdir;
 
     use super::{
-        set_reference_to_oplog, GITBUTLER_COMMIT_AUTHOR_EMAIL, GITBUTLER_COMMIT_AUTHOR_NAME,
+        set_reference_to_oplog, ReflogCommits, GITBUTLER_COMMIT_AUTHOR_EMAIL,
+        GITBUTLER_COMMIT_AUTHOR_NAME,
     };
 
     #[test]
@@ -141,12 +179,12 @@ mod set_target_ref {
         let worktree_dir = dir.path();
 
         let oplog = git2::Oid::from_str("0123456789abcdef0123456789abcdef0123456")?;
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let log_file_path = worktree_dir.join(".git/logs/refs/heads/gitbutler/target");
         std::fs::write(&log_file_path, [])?;
 
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let contents = std::fs::read_to_string(&log_file_path)?;
         assert_eq!(reflog_lines(&contents).len(), 2);
@@ -162,12 +200,12 @@ mod set_target_ref {
         let worktree_dir = dir.path();
 
         let oplog = git2::Oid::from_str("0123456789abcdef0123456789abcdef0123456")?;
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let log_file_path = worktree_dir.join(".git/logs/refs/heads/gitbutler/target");
         std::fs::write(&log_file_path, b"a gobbled mess that is no reflog")?;
 
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let contents = std::fs::read_to_string(&log_file_path)?;
         assert_eq!(reflog_lines(&contents).len(), 2);
@@ -180,12 +218,12 @@ mod set_target_ref {
         let worktree_dir = dir.path();
 
         let oplog = git2::Oid::from_str("0123456789abcdef0123456789abcdef0123456")?;
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let loose_ref_path = worktree_dir.join(".git/refs/heads/gitbutler/target");
         std::fs::remove_file(&loose_ref_path)?;
 
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
         assert!(
             loose_ref_path.is_file(),
             "the file was recreated, just in case there is only a reflog and no branch"
@@ -199,12 +237,12 @@ mod set_target_ref {
         let worktree_dir = dir.path();
 
         let oplog = git2::Oid::from_str("0123456789abcdef0123456789abcdef0123456")?;
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
 
         let log_file_path = worktree_dir.join(".git/logs/refs/heads/gitbutler/target");
         std::fs::remove_file(&log_file_path)?;
 
-        set_reference_to_oplog(worktree_dir, commit_id, oplog)
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog))
             .expect("missing reflog files are recreated");
         assert!(log_file_path.is_file(), "the file was recreated");
 
@@ -227,7 +265,7 @@ mod set_target_ref {
         // Set ref for the first time
         let oplog_hex = "0123456789abcdef0123456789abcdef01234567";
         let oplog = git2::Oid::from_str(oplog_hex)?;
-        set_reference_to_oplog(worktree_dir, commit_id, oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, oplog)).expect("success");
         assert!(log_file_path.exists());
         let contents = std::fs::read_to_string(&log_file_path)?;
         let lines = reflog_lines(&contents);
@@ -261,7 +299,8 @@ mod set_target_ref {
         // Update the oplog head only
         let another_oplog_hex = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
         let another_oplog = git2::Oid::from_str(another_oplog_hex)?;
-        set_reference_to_oplog(worktree_dir, commit_id, another_oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(commit_id, another_oplog))
+            .expect("success");
 
         let contents = std::fs::read_to_string(&log_file_path)?;
         let lines: Vec<_> = reflog_lines(&contents);
@@ -290,7 +329,8 @@ mod set_target_ref {
         // Update the target head only
         let new_target_hex = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
         let new_target = git2::Oid::from_str(new_target_hex)?;
-        set_reference_to_oplog(worktree_dir, new_target, another_oplog).expect("success");
+        set_reference_to_oplog(worktree_dir, reflog_commits(new_target, another_oplog))
+            .expect("success");
 
         let contents = std::fs::read_to_string(&log_file_path)?;
         let lines: Vec<_> = reflog_lines(&contents);
@@ -335,6 +375,14 @@ mod set_target_ref {
         );
     }
 
+    fn reflog_commits(target: git2::Oid, oplog: git2::Oid) -> ReflogCommits {
+        ReflogCommits {
+            target: target.to_gix(),
+            oplog: Some(oplog.to_gix()),
+            last_pushed_base: None,
+        }
+    }
+
     fn setup_repo() -> anyhow::Result<(tempfile::TempDir, git2::Oid)> {
         let dir = tempdir()?;
         let repo = git2::Repository::init(dir.path())?;
diff --git a/crates/gitbutler-serde/Cargo.toml b/crates/gitbutler-serde/Cargo.toml
index e2df75acec..78756e56ec 100644
--- a/crates/gitbutler-serde/Cargo.toml
+++ b/crates/gitbutler-serde/Cargo.toml
@@ -8,5 +8,6 @@ publish = false
 [dependencies]
 git2.workspace = true
 gix.workspace = true
-serde = { workspace = true, features = ["std"]}
+serde = { workspace = true, features = ["std"] }
 bstr.workspace = true
+gitbutler-oxidize.workspace = true
diff --git a/crates/gitbutler-serde/src/lib.rs b/crates/gitbutler-serde/src/lib.rs
index 9f1d3246a2..f938f36dd7 100644
--- a/crates/gitbutler-serde/src/lib.rs
+++ b/crates/gitbutler-serde/src/lib.rs
@@ -44,6 +44,31 @@ pub mod oid_opt {
     }
 }
 
+pub mod object_id_opt {
+    use gitbutler_oxidize::{ObjectIdExt, OidExt};
+    use serde::{Deserialize, Deserializer, Serialize};
+
+    pub fn serialize<S>(v: &Option<gix::ObjectId>, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        v.as_ref().map(|v| v.to_git2().to_string()).serialize(s)
+    }
+
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<gix::ObjectId>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let hex = <Option<String> as Deserialize>::deserialize(d)?;
+        hex.map(|v| {
+            v.parse::<git2::Oid>()
+                .map(|oid| oid.to_gix())
+                .map_err(|err: git2::Error| serde::de::Error::custom(err.to_string()))
+        })
+        .transpose()
+    }
+}
+
 pub mod oid_vec {
     use serde::{Deserialize, Deserializer, Serialize};
 
diff --git a/crates/gitbutler-stack/Cargo.toml b/crates/gitbutler-stack/Cargo.toml
index 44ae2bcb78..e0485343dd 100644
--- a/crates/gitbutler-stack/Cargo.toml
+++ b/crates/gitbutler-stack/Cargo.toml
@@ -25,13 +25,17 @@ gitbutler-fs.workspace = true
 gitbutler-command-context.workspace = true
 gitbutler-repo.workspace = true
 gitbutler-commit.workspace = true
+gitbutler-oxidize.workspace = true
+uuid.workspace = true
 
 [[test]]
 name = "stack"
 path = "tests/mod.rs"
 
 [dev-dependencies]
-gitbutler-git = { workspace = true, features = ["test-askpass-path"] } # Runtime test dependency
+gitbutler-git = { workspace = true, features = [
+    "test-askpass-path",
+] } # Runtime test dependency
 gitbutler-testsupport.workspace = true
 gitbutler-repo-actions.workspace = true
 tempfile = "3.14"
diff --git a/crates/gitbutler-stack/src/heads.rs b/crates/gitbutler-stack/src/heads.rs
index 7112a8fdec..7d3bfd2110 100644
--- a/crates/gitbutler-stack/src/heads.rs
+++ b/crates/gitbutler-stack/src/heads.rs
@@ -150,6 +150,7 @@ mod test {
             description: None,
             pr_number: None,
             archived: true,
+            review_id: "asdf".into(),
         };
         let head_2 = StackBranch {
             head: CommitOrChangeId::ChangeId("11609175-039d-44ee-9d4a-6baa9ad2a750".to_string()),
@@ -157,6 +158,7 @@ mod test {
             description: None,
             pr_number: None,
             archived: false,
+            review_id: "asdf".into(),
         };
         let existing_heads = vec![head_1_archived.clone(), head_2.clone()];
         let new_head = StackBranch {
@@ -165,6 +167,7 @@ mod test {
             description: None,
             pr_number: None,
             archived: false,
+            review_id: "asdf".into(),
         };
         let patches = vec![
             CommitOrChangeId::ChangeId("92a89ae608d77ff75c1ce52ea9dccc0bccd577e9".to_string()),
diff --git a/crates/gitbutler-stack/src/stack.rs b/crates/gitbutler-stack/src/stack.rs
index c0653222e7..b6b03d24fa 100644
--- a/crates/gitbutler-stack/src/stack.rs
+++ b/crates/gitbutler-stack/src/stack.rs
@@ -316,6 +316,7 @@ impl Stack {
             description: None,
             pr_number: Default::default(),
             archived: Default::default(),
+            review_id: uuid::Uuid::new_v4().to_string(),
         };
         let state = branch_state(ctx);
 
@@ -398,6 +399,7 @@ impl Stack {
             description,
             pr_number: Default::default(),
             archived: Default::default(),
+            review_id: uuid::Uuid::new_v4().to_string(),
         };
         self.add_series(ctx, new_head, Some(current_top_head.name.clone()))
     }
diff --git a/crates/gitbutler-stack/src/stack_branch.rs b/crates/gitbutler-stack/src/stack_branch.rs
index 04856af70a..fe1c061fe0 100644
--- a/crates/gitbutler-stack/src/stack_branch.rs
+++ b/crates/gitbutler-stack/src/stack_branch.rs
@@ -29,6 +29,12 @@ pub struct StackBranch {
     /// This would occur when the branch has been merged at the remote and the workspace has been updated with that change.
     #[serde(default)]
     pub archived: bool,
+
+    #[serde(default = "random_uuid")]
+    pub review_id: String,
+}
+fn random_uuid() -> String {
+    uuid::Uuid::new_v4().to_string()
 }
 
 /// A patch identifier which is either `CommitId` or a `ChangeId`.
diff --git a/crates/gitbutler-stack/src/state.rs b/crates/gitbutler-stack/src/state.rs
index 9ae784ca29..2e55021d61 100644
--- a/crates/gitbutler-stack/src/state.rs
+++ b/crates/gitbutler-stack/src/state.rs
@@ -7,8 +7,9 @@ use anyhow::{anyhow, Result};
 use git2::Repository;
 use gitbutler_error::error::Code;
 use gitbutler_fs::read_toml_file_or_default;
-// use gitbutler_project::Project;
+use gitbutler_oxidize::OidExt as _;
 use gitbutler_reference::Refname;
+use gitbutler_serde::object_id_opt;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
@@ -26,6 +27,9 @@ pub struct VirtualBranches {
     branch_targets: HashMap<StackId, Target>,
     /// The current state of the virtual branches
     branches: HashMap<StackId, Stack>,
+
+    #[serde(with = "object_id_opt", default)]
+    last_pushed_base: Option<gix::ObjectId>,
 }
 
 impl VirtualBranches {
@@ -95,6 +99,14 @@ impl VirtualBranchesHandle {
             .ok_or(anyhow!("there is no default target").context(Code::DefaultTargetNotFound))
     }
 
+    /// Gets the default target for the given repository.
+    ///
+    /// Errors if the file cannot be read or written.
+    pub fn maybe_get_default_target(&self) -> Result<Option<Target>> {
+        let virtual_branches = self.read_file()?;
+        Ok(virtual_branches.default_target)
+    }
+
     /// Sets the state of the given virtual branch.
     ///
     /// Errors if the file cannot be read or written.
@@ -159,6 +171,7 @@ impl VirtualBranchesHandle {
     /// if that branch doesn't exist.
     pub fn try_stack(&self, id: StackId) -> Result<Option<Stack>> {
         let virtual_branches = self.read_file()?;
+        dbg!(&virtual_branches);
         Ok(virtual_branches.branches.get(&id).cloned())
     }
 
@@ -272,8 +285,81 @@ impl VirtualBranchesHandle {
 
         Ok(())
     }
+
+    /// Returns a base commit for use when pushing a stack for review.
+    /// The last pushed base either has no parents, or either has the base
+    /// that was pushed previously as the base.
+    ///
+    /// The returned commit will always have the same tree as
+    /// `default_target.sha`.
+    ///
+    /// This function will return `Ok(None)` if there is no default target.
+    pub fn upsert_last_pushed_base(
+        &self,
+        repository: &gix::Repository,
+    ) -> Result<Option<gix::ObjectId>> {
+        let mut virtual_branches = self.read_file()?;
+        let Some(default_target) = &virtual_branches.default_target else {
+            return Ok(None);
+        };
+
+        let base_tree_id = repository
+            .find_commit(default_target.sha.to_gix())?
+            .tree_id()?
+            .detach();
+
+        if let Some(last_pushed_base) = virtual_branches.last_pushed_base {
+            let last_pushed_tree = repository
+                .find_commit(last_pushed_base)?
+                .tree_id()?
+                .detach();
+
+            // If the base commit's tree is the same as the previously pushed
+            // one, we have no need to update it.
+            if base_tree_id == last_pushed_tree {
+                return Ok(Some(last_pushed_base));
+            }
+
+            virtual_branches.last_pushed_base = Some(alter_parentage(
+                repository,
+                default_target.sha.to_gix(),
+                &[last_pushed_base],
+            )?);
+        } else {
+            // There was no previous last_pushed_base to point to, so we create
+            // the first base which doesn't have any parents.
+            virtual_branches.last_pushed_base = Some(alter_parentage(
+                repository,
+                default_target.sha.to_gix(),
+                &[],
+            )?);
+        }
+
+        self.write_file(&virtual_branches)?;
+
+        Ok(virtual_branches.last_pushed_base)
+    }
+
+    /// Provides direct access to the last_pushed_base. If you are actually
+    /// pushing, you probably want
+    pub fn last_pushed_base(&self) -> Result<Option<gix::ObjectId>> {
+        let virtual_branches = self.read_file()?;
+        Ok(virtual_branches.last_pushed_base)
+    }
 }
 
 fn write<P: AsRef<Path>>(file_path: P, virtual_branches: &VirtualBranches) -> Result<()> {
     gitbutler_fs::write(file_path, toml::to_string(&virtual_branches)?)
 }
+
+/// Re-commit a commit with altered parentage
+fn alter_parentage(
+    repository: &gix::Repository,
+    to_rewrite: gix::ObjectId,
+    new_parents: &[gix::ObjectId],
+) -> Result<gix::ObjectId> {
+    let mut to_rewrite: gix::objs::Commit = repository.find_commit(to_rewrite)?.decode()?.into();
+    to_rewrite.parents = new_parents.into();
+    to_rewrite.extra_headers.retain(|entry| entry.0 != "gpgsig");
+    Ok(repository.write_object(to_rewrite)?.into())
+}
diff --git a/crates/gitbutler-stack/tests/mod.rs b/crates/gitbutler-stack/tests/mod.rs
index 3bf0b9c4af..9f82cd1025 100644
--- a/crates/gitbutler-stack/tests/mod.rs
+++ b/crates/gitbutler-stack/tests/mod.rs
@@ -22,6 +22,7 @@ fn add_series_success() -> Result<()> {
         description: Some("my description".into()),
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference, None);
     assert!(result.is_ok());
@@ -76,6 +77,7 @@ fn add_series_top_base() -> Result<()> {
         description: Some("my description".into()),
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference, None);
     println!("{:?}", result);
@@ -102,6 +104,7 @@ fn add_multiple_series() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx
         .stack
@@ -115,6 +118,7 @@ fn add_multiple_series() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, head_2, None);
     assert!(result.is_ok());
@@ -129,6 +133,7 @@ fn add_multiple_series() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
 
     let result = test_ctx.stack.add_series(&ctx, head_1, None);
@@ -155,6 +160,7 @@ fn add_series_commit_id_when_change_id_available() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference, None);
     assert_eq!(
@@ -177,6 +183,7 @@ fn add_series_invalid_name_fails() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference, None);
     assert_eq!(result.err().unwrap().to_string(), "Invalid branch name");
@@ -193,6 +200,7 @@ fn add_series_duplicate_name_fails() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert!(result.is_ok());
@@ -214,6 +222,7 @@ fn add_series_matching_git_ref_is_ok() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert!(result.is_ok()); // allow this
@@ -230,6 +239,7 @@ fn add_series_including_refs_head_fails() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert_eq!(
@@ -249,6 +259,7 @@ fn add_series_target_commit_doesnt_exist() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert!(result
@@ -269,6 +280,7 @@ fn add_series_target_change_id_doesnt_exist() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert_eq!(
@@ -289,6 +301,7 @@ fn add_series_target_commit_not_in_stack() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, reference.clone(), None);
     assert_eq!(
@@ -344,6 +357,7 @@ fn remove_series_with_multiple_last_heads() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, to_stay.clone(), None);
     assert!(result.is_ok());
@@ -376,6 +390,7 @@ fn remove_series_no_orphan_commits() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     }; // references the oldest commit
     let result = test_ctx.stack.add_series(&ctx, to_stay.clone(), None);
     assert!(result.is_ok());
@@ -558,6 +573,7 @@ fn update_series_target_success() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let result = test_ctx.stack.add_series(&ctx, series_1, None);
     assert!(result.is_ok());
@@ -660,6 +676,7 @@ fn list_series_two_heads_same_commit() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     // add `head_before` before the initial head
     let result = test_ctx.stack.add_series(&ctx, head_before, None);
@@ -706,6 +723,7 @@ fn list_series_two_heads_different_commit() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
 
     let stack_context = ctx.to_stack_context()?;
@@ -781,6 +799,7 @@ fn replace_head_single() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     test_ctx.stack.add_series(&ctx, from_head, None)?;
     // replace with previous head
@@ -814,6 +833,7 @@ fn replace_head_single_with_merge_base() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     test_ctx.stack.add_series(&ctx, from_head, None)?;
     // replace with merge base
@@ -851,6 +871,7 @@ fn replace_head_with_invalid_commit_error() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     test_ctx.stack.add_series(&ctx, from_head, None)?;
     let stack = test_ctx.stack.clone();
@@ -879,6 +900,7 @@ fn replace_head_with_same_noop() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     test_ctx.stack.add_series(&ctx, from_head, None)?;
     let stack = test_ctx.stack.clone();
@@ -966,6 +988,7 @@ fn replace_head_multiple() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     let from_head_2 = StackBranch {
         name: "from_head_2".into(),
@@ -973,6 +996,7 @@ fn replace_head_multiple() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     // both references point to the same commit
     test_ctx.stack.add_series(&ctx, from_head_1, None)?;
@@ -1014,6 +1038,7 @@ fn replace_head_top_of_stack_multiple() -> Result<()> {
         description: None,
         pr_number: Default::default(),
         archived: Default::default(),
+        review_id: "asdf".into(),
     };
     // an extra head just beneath the top of the stack
     test_ctx.stack.add_series(&ctx, extra_head, None)?;
@@ -1070,6 +1095,7 @@ fn archive_heads_success() -> Result<()> {
             description: None,
             pr_number: Default::default(),
             archived: Default::default(),
+            review_id: "asdf".into(),
         },
     );
     assert_eq!(test_ctx.stack.heads.len(), 2);
diff --git a/crates/gitbutler-sync/Cargo.toml b/crates/gitbutler-sync/Cargo.toml
index e938c5ab04..23d1eecf0f 100644
--- a/crates/gitbutler-sync/Cargo.toml
+++ b/crates/gitbutler-sync/Cargo.toml
@@ -10,6 +10,7 @@ anyhow = "1.0.95"
 tracing.workspace = true
 itertools = "0.14"
 git2.workspace = true
+gix.workspace = true
 gitbutler-oplog.workspace = true
 gitbutler-command-context.workspace = true
 gitbutler-project.workspace = true
@@ -20,3 +21,4 @@ gitbutler-error.workspace = true
 gitbutler-id.workspace = true
 gitbutler-url.workspace = true
 gitbutler-stack.workspace = true
+gitbutler-oxidize.workspace = true
diff --git a/crates/gitbutler-sync/src/cloud.rs b/crates/gitbutler-sync/src/cloud.rs
index 9cd0132cc9..345134db5b 100644
--- a/crates/gitbutler-sync/src/cloud.rs
+++ b/crates/gitbutler-sync/src/cloud.rs
@@ -239,7 +239,7 @@ fn update_project(
     Ok(())
 }
 
-fn push_to_gitbutler_server(
+pub(crate) fn push_to_gitbutler_server(
     ctx: &CommandContext,
     user: Option<&users::User>,
     ref_specs: &[&str],
@@ -299,11 +299,11 @@ fn push_to_gitbutler_server(
     Ok(total_objects_pushed > 0)
 }
 
-enum RemoteKind {
+pub(crate) enum RemoteKind {
     Code,
     Oplog,
 }
-fn remote(ctx: &CommandContext, kind: RemoteKind) -> Result<git2::Remote> {
+pub(crate) fn remote(ctx: &CommandContext, kind: RemoteKind) -> Result<git2::Remote> {
     let api_project = ctx.project().api.as_ref().context("api not set")?;
     let url = match kind {
         RemoteKind::Code => {
diff --git a/crates/gitbutler-sync/src/lib.rs b/crates/gitbutler-sync/src/lib.rs
index 1ede32218e..deecbbed1f 100644
--- a/crates/gitbutler-sync/src/lib.rs
+++ b/crates/gitbutler-sync/src/lib.rs
@@ -1 +1,2 @@
 pub mod cloud;
+pub mod stack_upload;
diff --git a/crates/gitbutler-sync/src/stack_upload.rs b/crates/gitbutler-sync/src/stack_upload.rs
new file mode 100644
index 0000000000..4e119e736e
--- /dev/null
+++ b/crates/gitbutler-sync/src/stack_upload.rs
@@ -0,0 +1,183 @@
+#![forbid(rust_2018_idioms)]
+
+use anyhow::{bail, Result};
+// A happy little module for uploading stacks.
+
+use gitbutler_command_context::CommandContext;
+use gitbutler_oplog::reflog::{set_reference_to_oplog, ReflogCommits};
+use gitbutler_oxidize::OidExt as _;
+use gitbutler_stack::{
+    stack_context::{CommandContextExt, StackContext},
+    Stack, StackId, VirtualBranchesHandle,
+};
+use gitbutler_user::User;
+use gix::bstr::{BString, ByteSlice, ByteVec as _};
+
+use crate::cloud::{push_to_gitbutler_server, remote, RemoteKind};
+
+pub fn push_stack_to_review(ctx: &CommandContext, user: &User, stack_id: StackId) -> Result<()> {
+    let vb_state = VirtualBranchesHandle::new(ctx.project().gb_dir());
+    let stack = vb_state.get_stack(stack_id)?;
+    let repository = ctx.gix_repository()?;
+    // We set the stack immediatly after because it might be an old stack that
+    // dosn't yet have review_ids assigned. When reading they will have been
+    // assigned new review_ids, so we just need to persist them here.
+    vb_state.set_stack(stack.clone())?;
+    let stack_context = ctx.to_stack_context()?;
+
+    let branch_heads = branch_heads(&stack, &stack_context)?;
+    let Some(review_base_id) = vb_state.upsert_last_pushed_base(&repository)? else {
+        bail!("This is impossible. If you got here, I'm sorry.");
+    };
+    set_reference_to_oplog(&ctx.project().path, ReflogCommits::new(ctx.project())?)?;
+
+    let target_commit_id = vb_state.get_default_target()?.sha.to_gix();
+    let commits = repository
+        .rev_walk([stack.head().to_gix()])
+        .first_parent_only()
+        .with_pruned([target_commit_id])
+        .sorting(gix::revision::walk::Sorting::BreadthFirst)
+        .all()?
+        .filter_map(|e| Some(e.ok()?.id().detach()))
+        .collect::<Vec<_>>();
+
+    let review_head =
+        format_stack_for_review(&repository, &commits, &branch_heads, review_base_id)?;
+
+    let refspec = format_refspec(&review_head);
+
+    let remote = remote(ctx, RemoteKind::Oplog)?;
+    push_to_gitbutler_server(ctx, Some(user), &[&refspec], remote)?;
+
+    Ok(())
+}
+
+fn format_refspec(sha: &gix::ObjectId) -> String {
+    format!("+{}:refs/review/publish", sha)
+}
+
+struct BranchHead {
+    name: String,
+    review_id: String,
+    id: gix::ObjectId,
+}
+
+/// Fetch the stack heads in order
+fn branch_heads(stack: &Stack, stack_context: &StackContext<'_>) -> Result<Vec<BranchHead>> {
+    let mut heads = vec![];
+    for head in &stack.heads {
+        let head_oid = head.head_oid(stack_context, stack)?.to_gix();
+        heads.push(BranchHead {
+            id: head_oid,
+            review_id: head.review_id.clone(),
+            name: head.name.to_owned(),
+        })
+    }
+
+    Ok(heads)
+}
+
+struct CommitMessage {
+    title: BString,
+    body: BString,
+    trailers: Vec<(BString, BString)>,
+}
+
+impl CommitMessage {
+    // I tried not allocating but couldn't get it right. This works fine
+    fn to_bstring(&self) -> BString {
+        let mut out = BString::default();
+        out.push_str(self.title.clone());
+        out.push_str(b"\n\n");
+        out.push_str(self.body.clone());
+        out.push_str(b"\n\n");
+        out.push_str(self.trailers_as_bstring());
+        out
+    }
+
+    fn trailers_as_bstring(&self) -> BString {
+        let mut out = BString::default();
+        for (index, trailer) in self.trailers.iter().enumerate() {
+            let trailer = gix::bstr::join(": ", [&trailer.0, &trailer.1]);
+            out.push_str(trailer);
+
+            if index != self.trailers.len() - 1 {
+                out.push_str(b"\n")
+            }
+        }
+        out
+    }
+
+    fn new(commit: gix::objs::CommitRef<'_>) -> Self {
+        let message_ref = commit.message();
+        let body_ref = message_ref.body();
+
+        CommitMessage {
+            title: commit.message().title.to_owned(),
+            body: body_ref
+                .map(|body_ref| body_ref.without_trailer().as_bstr().to_owned())
+                .unwrap_or_default(),
+            trailers: body_ref
+                .map(|body_ref| {
+                    body_ref
+                        .trailers()
+                        .map(|trailer| (trailer.token.to_owned(), trailer.value.to_owned()))
+                        .collect::<Vec<_>>()
+                })
+                .unwrap_or_default(),
+        }
+    }
+}
+
+/// Rewrites a series of commits in preperation for pusing to gitbutler review.
+///
+/// The heads and commits should be passed in child-most to parent-most order.
+///
+/// Returns the head of stack.
+fn format_stack_for_review(
+    repository: &gix::Repository,
+    commits: &[gix::ObjectId],
+    heads: &[BranchHead],
+    base_commit: gix::ObjectId,
+) -> Result<gix::ObjectId> {
+    let mut previous_commit = base_commit;
+
+    for (index, commit_id) in commits.iter().enumerate().rev() {
+        let commit = repository.find_commit(*commit_id)?;
+        let decoded_commit = commit.decode()?;
+        let mut message = CommitMessage::new(decoded_commit.clone());
+        let mut object: gix::objs::Commit = decoded_commit.into();
+
+        // The parent-most commit is the last one in the array
+        if index == commits.len() - 1 {
+            message
+                .trailers
+                .push((b"Base-Commit".into(), base_commit.to_string().into()));
+        }
+
+        message
+            .trailers
+            .push((b"Original-Commit".into(), commit_id.to_string().into()));
+
+        'heads: for stack_head in heads {
+            if stack_head.id != *commit_id {
+                continue 'heads;
+            }
+
+            let value = format!("{}, {}", stack_head.name, stack_head.review_id)
+                .as_bytes()
+                .as_bstr()
+                .to_owned();
+            message.trailers.push((b"Branch-Head".into(), value))
+        }
+
+        object.message = message.to_bstring();
+        // Remove the signing header so we don't have an invalid signature
+        object.extra_headers.retain(|entry| entry.0 != "gpgsig");
+        object.parents = [previous_commit].into();
+
+        previous_commit = repository.write_object(object)?.detach();
+    }
+
+    Ok(previous_commit)
+}
diff --git a/crates/gitbutler-tauri/src/main.rs b/crates/gitbutler-tauri/src/main.rs
index 210ea94aa3..7087c58d8f 100644
--- a/crates/gitbutler-tauri/src/main.rs
+++ b/crates/gitbutler-tauri/src/main.rs
@@ -219,6 +219,7 @@ fn main() {
                     stack::update_series_description,
                     stack::update_series_pr_number,
                     stack::push_stack,
+                    stack::push_stack_to_review,
                     secret::secret_get_global,
                     secret::secret_set_global,
                     undo::list_snapshots,
diff --git a/crates/gitbutler-tauri/src/stack.rs b/crates/gitbutler-tauri/src/stack.rs
index a8279caac6..2383bb4dbd 100644
--- a/crates/gitbutler-tauri/src/stack.rs
+++ b/crates/gitbutler-tauri/src/stack.rs
@@ -1,7 +1,9 @@
 use gitbutler_branch_actions::stack::CreateSeriesRequest;
+use gitbutler_command_context::CommandContext;
 use gitbutler_project as projects;
 use gitbutler_project::ProjectId;
 use gitbutler_stack::StackId;
+use gitbutler_user::User;
 use tauri::State;
 use tracing::instrument;
 
@@ -112,3 +114,18 @@ pub fn push_stack(
     emit_vbranches(&windows, project_id);
     Ok(())
 }
+
+#[tauri::command(async)]
+#[instrument(skip(projects), err(Debug))]
+pub fn push_stack_to_review(
+    projects: State<'_, projects::Controller>,
+    project_id: ProjectId,
+    stack_id: StackId,
+    user: User,
+) -> Result<(), Error> {
+    let project = projects.get(project_id)?;
+    let ctx = CommandContext::open(&project)?;
+    gitbutler_sync::stack_upload::push_stack_to_review(&ctx, &user, stack_id)?;
+
+    Ok(())
+}