diff --git a/apps/desktop/src/components/forge/BaseBranchSwitch.svelte b/apps/desktop/src/components/forge/BaseBranchSwitch.svelte
index 62016e8a755..37d4637e9fa 100644
--- a/apps/desktop/src/components/forge/BaseBranchSwitch.svelte
+++ b/apps/desktop/src/components/forge/BaseBranchSwitch.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
 	import { BASE_BRANCH_SERVICE } from "$lib/baseBranch/baseBranchService.svelte";
+	import { SETTINGS_SERVICE } from "$lib/settings/appSettings";
 	import { STACK_SERVICE } from "$lib/stacks/stackService.svelte";
 	import { inject } from "@gitbutler/core/context";
 	import { Button, CardGroup, InfoMessage, Select, SelectItem } from "@gitbutler/ui";
@@ -8,10 +9,12 @@
 
 	const stackService = inject(STACK_SERVICE);
 	const baseBranchService = inject(BASE_BRANCH_SERVICE);
+	const settingsStore = inject(SETTINGS_SERVICE).appSettings;
 	const baseBranchQuery = $derived(baseBranchService.baseBranch(projectId));
 	const baseBranch = $derived(baseBranchQuery.response);
 	const remoteBranchesQuery = $derived(baseBranchService.remoteBranches(projectId));
 	const [setBaseBranchTarget, targetBranchSwitch] = baseBranchService.setTarget;
+	const [setBaseBranchTargetRef, targetRefSwitch] = baseBranchService.setTargetRef;
 
 	let selectedBranch = $derived(baseBranch?.branchName);
 	let selectedRemote = $derived(baseBranch?.pushRemoteName);
@@ -28,8 +31,22 @@
 			}));
 	}
 
+	const switching = $derived(
+		targetBranchSwitch.current.isLoading || targetRefSwitch.current.isLoading,
+	);
+	// With the singleBranch feature flag, only the target metadata is rewritten
+	// and no branch is checked out, so avoid claiming a branch switch.
+	const switchingLabel = $derived(
+		$settingsStore?.featureFlags.singleBranch ? "Updating target..." : "Switching branches...",
+	);
+
 	async function switchTarget(branch: string, pushRemote?: string) {
-		await setBaseBranchTarget({ projectId, branch, pushRemote });
+		if ($settingsStore?.featureFlags.singleBranch) {
+			// Only update the target; the user keeps working on their current branch.
+			await setBaseBranchTargetRef({ projectId, targetRef: `refs/remotes/${branch}`, pushRemote });
+		} else {
+			await setBaseBranchTarget({ projectId, branch, pushRemote });
+		}
 	}
 
 	async function onSetBaseBranchClick() {
@@ -113,14 +130,12 @@
 						kind="outline"
 						onclick={onSetBaseBranchClick}
 						id="set-base-branch"
-						loading={targetBranchSwitch.current.isLoading}
+						loading={switching}
 						disabled={(selectedBranch === baseBranch?.branchName &&
 							selectedRemote === baseBranch?.pushRemoteName) ||
 							targetChangeDisabled}
 					>
-						{targetBranchSwitch.current.isLoading
-							? "Switching branches..."
-							: "Update configuration"}
+						{switching ? switchingLabel : "Update configuration"}
 					</Button>
 				{/if}
 			</CardGroup.Item>
diff --git a/apps/desktop/src/components/onboarding/ProjectSetup.svelte b/apps/desktop/src/components/onboarding/ProjectSetup.svelte
index 0ea09e980f1..6fb6c94f90b 100644
--- a/apps/desktop/src/components/onboarding/ProjectSetup.svelte
+++ b/apps/desktop/src/components/onboarding/ProjectSetup.svelte
@@ -6,6 +6,7 @@
 	import newZenSvg from "$lib/assets/illustrations/new-zen.svg?raw";
 	import { BASE_BRANCH_SERVICE } from "$lib/baseBranch/baseBranchService.svelte";
 	import { PROJECTS_SERVICE } from "$lib/project/projectsService";
+	import { SETTINGS_SERVICE } from "$lib/settings/appSettings";
 	import { OnboardingEvent, POSTHOG_WRAPPER } from "$lib/telemetry/posthog";
 	import { inject } from "@gitbutler/core/context";
 	import { TestId } from "@gitbutler/ui";
@@ -21,18 +22,29 @@
 	const projectsService = inject(PROJECTS_SERVICE);
 	const baseService = inject(BASE_BRANCH_SERVICE);
 	const posthog = inject(POSTHOG_WRAPPER);
+	const settingsStore = inject(SETTINGS_SERVICE).appSettings;
 	const projectQuery = $derived(projectsService.getProject(projectId));
 	const [setBaseBranchTarget] = baseService.setTarget;
+	const [setBaseBranchTargetRef] = baseService.setTargetRef;
 
 	async function setTarget(branch: string[]) {
 		if (!branch[0] || branch[0] === "") return;
 
 		try {
-			await setBaseBranchTarget({
-				projectId: projectId,
-				branch: branch[0],
-				pushRemote: branch[1],
-			});
+			if ($settingsStore?.featureFlags.singleBranch) {
+				// Only set the target; the user keeps working on their current branch.
+				await setBaseBranchTargetRef({
+					projectId: projectId,
+					targetRef: `refs/remotes/${branch[0]}`,
+					pushRemote: branch[1],
+				});
+			} else {
+				await setBaseBranchTarget({
+					projectId: projectId,
+					branch: branch[0],
+					pushRemote: branch[1],
+				});
+			}
 			posthog.captureOnboarding(OnboardingEvent.SetTargetBranch);
 			goto(`/${projectId}/`, { invalidateAll: true });
 		} catch (e: unknown) {
diff --git a/apps/desktop/src/components/onboarding/ProjectSetupTarget.svelte b/apps/desktop/src/components/onboarding/ProjectSetupTarget.svelte
index 823d1c3e53b..2b2f5bcd77d 100644
--- a/apps/desktop/src/components/onboarding/ProjectSetupTarget.svelte
+++ b/apps/desktop/src/components/onboarding/ProjectSetupTarget.svelte
@@ -6,6 +6,7 @@
 	import { projectLandDirectly } from "$lib/config/config";
 	import { GIT_CONFIG_SERVICE } from "$lib/config/gitConfigService";
 	import { PROJECTS_SERVICE } from "$lib/project/projectsService";
+	import { SETTINGS_SERVICE } from "$lib/settings/appSettings";
 	import { combineResults } from "$lib/state/helpers";
 	import { OnboardingEvent, POSTHOG_WRAPPER } from "$lib/telemetry/posthog";
 	import { unique } from "$lib/utils/array";
@@ -35,6 +36,7 @@
 
 	const posthog = inject(POSTHOG_WRAPPER);
 	const gitConfig = inject(GIT_CONFIG_SERVICE);
+	const settingsStore = inject(SETTINGS_SERVICE).appSettings;
 
 	const gbConfig = $derived(gitConfig.gbConfig(projectId));
 	const gerritMode = $derived(gbConfig.response?.gitbutlerGerritMode ?? false);
@@ -180,56 +182,62 @@
 		<span class="text-12 clr-text-2">Push to main / Skip pull requests mode</span>
 	</label>
 
-	<div
-		class="project-setup__info"
-		role="presentation"
-		onclick={() => (showMoreInfo = !showMoreInfo)}
-	>
-		<div class="project-setup__fold-icon" class:rotate-icon={showMoreInfo}>
-			<Icon name="chevron-right" />
-		</div>
-
-		<div class="stack-v gap-6 full-width">
-			<div class="project-setup__info__title">
-				<svg
-					width="16"
-					height="13"
-					viewBox="0 0 16 13"
-					fill="none"
-					xmlns="http://www.w3.org/2000/svg"
-				>
-					<path
-						d="M2 12L3.5 7.5M14 12L12.5 7.5M12.5 7.5L11 3H5L3.5 7.5M12.5 7.5H3.5"
-						stroke="#D96842"
-						stroke-width="1.5"
-					/>
-					<path
-						d="M1.24142 3H14.7586C14.8477 3 14.8923 2.89229 14.8293 2.82929L13.0293 1.02929C13.0105 1.01054 12.9851 1 12.9586 1H3.04142C3.0149 1 2.98946 1.01054 2.97071 1.02929L1.17071 2.82929C1.10771 2.89229 1.15233 3 1.24142 3Z"
-						fill="#FF9774"
-						stroke="#FF9774"
-						stroke-width="1.5"
-					/>
-				</svg>
-
-				<h3 class="text-13 text-body text-semibold">
-					GitButler switches your active branch to <span class="text-bold">gitbutler/workspace</span
-					>
-				</h3>
+	<!-- With the singleBranch feature flag, setting the target only updates project
+	     metadata and the user stays on their current branch, so don't promise a
+	     switch to gitbutler/workspace. -->
+	{#if !$settingsStore?.featureFlags.singleBranch}
+		<div
+			class="project-setup__info"
+			role="presentation"
+			onclick={() => (showMoreInfo = !showMoreInfo)}
+		>
+			<div class="project-setup__fold-icon" class:rotate-icon={showMoreInfo}>
+				<Icon name="chevron-right" />
 			</div>
 
-			{#if showMoreInfo}
-				<p class="text-12 text-body" transition:slide={{ duration: 200 }}>
-					In order to support working on multiple branches simultaneously, GitButler creates and
-					automatically manages a special branch <span class="text-bold">gitbutler/workspace</span>.
-					You can always switch back and forth as needed between normal git branches and the
-					Gitbutler workspace.
-					<Link href="https://docs.gitbutler.com/features/branch-management/integration-branch"
-						>Learn more</Link
+			<div class="stack-v gap-6 full-width">
+				<div class="project-setup__info__title">
+					<svg
+						width="16"
+						height="13"
+						viewBox="0 0 16 13"
+						fill="none"
+						xmlns="http://www.w3.org/2000/svg"
 					>
-				</p>
-			{/if}
+						<path
+							d="M2 12L3.5 7.5M14 12L12.5 7.5M12.5 7.5L11 3H5L3.5 7.5M12.5 7.5H3.5"
+							stroke="#D96842"
+							stroke-width="1.5"
+						/>
+						<path
+							d="M1.24142 3H14.7586C14.8477 3 14.8923 2.89229 14.8293 2.82929L13.0293 1.02929C13.0105 1.01054 12.9851 1 12.9586 1H3.04142C3.0149 1 2.98946 1.01054 2.97071 1.02929L1.17071 2.82929C1.10771 2.89229 1.15233 3 1.24142 3Z"
+							fill="#FF9774"
+							stroke="#FF9774"
+							stroke-width="1.5"
+						/>
+					</svg>
+
+					<h3 class="text-13 text-body text-semibold">
+						GitButler switches your active branch to <span class="text-bold"
+							>gitbutler/workspace</span
+						>
+					</h3>
+				</div>
+
+				{#if showMoreInfo}
+					<p class="text-12 text-body" transition:slide={{ duration: 200 }}>
+						In order to support working on multiple branches simultaneously, GitButler creates and
+						automatically manages a special branch <span class="text-bold">gitbutler/workspace</span
+						>. You can always switch back and forth as needed between normal git branches and the
+						Gitbutler workspace.
+						<Link href="https://docs.gitbutler.com/features/branch-management/integration-branch"
+							>Learn more</Link
+						>
+					</p>
+				{/if}
+			</div>
 		</div>
-	</div>
+	{/if}
 
 	<div class="action-buttons">
 		<Button kind="outline" onclick={deleteProjectAndGoBack}>Cancel</Button>
diff --git a/apps/desktop/src/lib/baseBranch/baseBranchService.svelte.ts b/apps/desktop/src/lib/baseBranch/baseBranchService.svelte.ts
index 61472d2fa4c..fe8f27e3c66 100644
--- a/apps/desktop/src/lib/baseBranch/baseBranchService.svelte.ts
+++ b/apps/desktop/src/lib/baseBranch/baseBranchService.svelte.ts
@@ -86,6 +86,10 @@ export default class BaseBranchService {
 		return this.backendApi.endpoints.setTarget.useMutation();
 	}
 
+	get setTargetRef() {
+		return this.backendApi.endpoints.setTargetRef.useMutation();
+	}
+
 	get switchBackToWorkspace() {
 		return this.backendApi.endpoints.switchBackToWorkspace.useMutation();
 	}
diff --git a/apps/desktop/src/lib/branches/branchEndpoints.ts b/apps/desktop/src/lib/branches/branchEndpoints.ts
index 8272ac70ab1..1091f2f8323 100644
--- a/apps/desktop/src/lib/branches/branchEndpoints.ts
+++ b/apps/desktop/src/lib/branches/branchEndpoints.ts
@@ -57,6 +57,24 @@ export function buildBranchEndpoints(build: BackendEndpointBuilder) {
 				invalidatesList(ReduxTag.StackDetails),
 			],
 		}),
+		// Like setTarget, but only writes project metadata: the user stays on the
+		// current branch instead of being moved into the GitButler workspace.
+		setTargetRef: build.mutation<
+			void,
+			{ projectId: string; targetRef: string; pushRemote?: string }
+		>({
+			extraOptions: { command: "set_target_ref_and_init_project" },
+			query: (args) => args,
+			invalidatesTags: [
+				invalidatesType(ReduxTag.ForgeProvider),
+				invalidatesType(ReduxTag.BaseBranchData),
+				invalidatesList(ReduxTag.Stacks),
+				invalidatesList(ReduxTag.StackDetails),
+				// No branch is checked out, so no `git/head` event refreshes the
+				// operating mode - invalidate it explicitly.
+				invalidatesList(ReduxTag.HeadMetadata),
+			],
+		}),
 		switchBackToWorkspace: build.mutation<BaseBranch, { projectId: string }>({
 			extraOptions: { command: "switch_back_to_workspace" },
 			query: (args) => args,
diff --git a/apps/lite/electron/src/ipc.ts b/apps/lite/electron/src/ipc.ts
index 4b149270568..09215c342d3 100644
--- a/apps/lite/electron/src/ipc.ts
+++ b/apps/lite/electron/src/ipc.ts
@@ -325,6 +325,12 @@ export interface SetReviewTemplateParams {
 	templatePath: string | null;
 }
 
+export interface SetTargetRefAndInitProjectParams {
+	projectId: string;
+	targetRef: string;
+	pushRemote?: string;
+}
+
 export interface TearOffBranchParams {
 	projectId: string;
 	subjectBranch: string;
@@ -476,6 +482,7 @@ export interface LiteElectronApi {
 	setReviewAutoMerge: (params: SetReviewAutoMergeParams) => Promise<void>;
 	setReviewDraftiness: (params: SetReviewDraftinessParams) => Promise<void>;
 	setReviewTemplate: (params: SetReviewTemplateParams) => Promise<void>;
+	setTargetRefAndInitProject: (params: SetTargetRefAndInitProjectParams) => Promise<void>;
 	showNativeMenu: (params: ShowNativeMenuParams) => Promise<string | null>;
 	treeChangeDiffs: (params: TreeChangeDiffParams) => Promise<UnifiedPatch | null>;
 	unapplyStack: (params: UnapplyStackParams) => Promise<void>;
@@ -556,6 +563,7 @@ export const liteIpcChannels = {
 	setReviewAutoMerge: "workspace:set-review-auto-merge",
 	setReviewDraftiness: "workspace:set-review-draftiness",
 	setReviewTemplate: "workspace:set-review-template",
+	setTargetRefAndInitProject: "workspace:set-target-ref-and-init-project",
 	showNativeMenu: "lite:show-native-menu",
 	treeChangeDiffs: "workspace:tree-change-diffs",
 	unapplyStack: "workspace:unapply-stack",
diff --git a/apps/lite/electron/src/main.ts b/apps/lite/electron/src/main.ts
index 6c289b61938..935eb757543 100644
--- a/apps/lite/electron/src/main.ts
+++ b/apps/lite/electron/src/main.ts
@@ -52,6 +52,7 @@ import {
 	type SetReviewAutoMergeParams,
 	type SetReviewDraftinessParams,
 	type SetReviewTemplateParams,
+	type SetTargetRefAndInitProjectParams,
 	type PeelRestoreSnapshotParams,
 	type WorkspaceIntegrateUpstreamParams,
 	type UpdateReviewFootersParams,
@@ -114,6 +115,7 @@ import {
 	setReviewAutoMerge,
 	setReviewDraftiness,
 	setReviewTemplate,
+	setTargetRefAndInitProject,
 	getUndoTargetSnapshot,
 	getRedoTargetSnapshot,
 	peelRestoreSnapshot,
@@ -657,6 +659,11 @@ const registerIpcHandlers = (): void => {
 		(_e, { projectId, templatePath }: SetReviewTemplateParams) =>
 			setReviewTemplate(projectId, templatePath),
 	);
+	senderValidatingHandle(
+		liteIpcChannels.setTargetRefAndInitProject,
+		(_e, { projectId, targetRef, pushRemote }: SetTargetRefAndInitProjectParams) =>
+			setTargetRefAndInitProject(projectId, targetRef, pushRemote ?? null),
+	);
 	senderValidatingHandle(
 		liteIpcChannels.showNativeMenu,
 		async (event, { items, position }: ShowNativeMenuParams) => {
diff --git a/apps/lite/electron/src/preload.cts b/apps/lite/electron/src/preload.cts
index 730fd13fe60..a89a35f5dc0 100644
--- a/apps/lite/electron/src/preload.cts
+++ b/apps/lite/electron/src/preload.cts
@@ -195,6 +195,8 @@ const api: LiteElectronApi = {
 		ipcRenderer.invoke("workspace:set-review-draftiness", params) as Promise<void>,
 	setReviewTemplate: (params) =>
 		ipcRenderer.invoke("workspace:set-review-template", params) as Promise<void>,
+	setTargetRefAndInitProject: (params) =>
+		ipcRenderer.invoke("workspace:set-target-ref-and-init-project", params) as Promise<void>,
 	showNativeMenu: (params) =>
 		ipcRenderer.invoke("lite:show-native-menu", params) as Promise<string | null>,
 	treeChangeDiffs: (params) =>
diff --git a/crates/but-api/src/branch.rs b/crates/but-api/src/branch.rs
index 6736704e8af..74581d82847 100644
--- a/crates/but-api/src/branch.rs
+++ b/crates/but-api/src/branch.rs
@@ -7,7 +7,7 @@ use but_api_macros::but_api;
 use but_core::{
     DryRun, RefMetadata, WORKSPACE_REF_NAME,
     branch::unique_canned_refname,
-    ref_metadata::{ProjectMeta, StackId},
+    ref_metadata::StackId,
     sync::RepoExclusive,
     ui::TreeChanges,
     update_head_reference,
@@ -59,75 +59,6 @@ pub struct BranchCheckoutResult {
     pub workspace: WorkspaceState,
 }
 
-/// Set the project default target without applying branches or entering managed workspace mode.
-///
-/// This acquires exclusive worktree access from `ctx` before updating project metadata.
-pub fn set_default_target(
-    ctx: &mut Context,
-    target_ref: &gix::refs::FullNameRef,
-    push_remote: Option<String>,
-) -> anyhow::Result<ProjectMeta> {
-    let mut guard = ctx.exclusive_worktree_access();
-    set_default_target_with_perm(ctx, target_ref, push_remote, guard.write_permission())
-}
-
-/// Set the project default target under caller-held exclusive repository access.
-///
-/// This is metadata-only: it writes [`ProjectMeta`] and deliberately does not create stack
-/// metadata, create or update `gitbutler/workspace`, checkout any ref, update the index, record
-/// oplog state, or install managed workspace hooks.
-pub fn set_default_target_with_perm(
-    ctx: &mut Context,
-    target_ref: &gix::refs::FullNameRef,
-    push_remote: Option<String>,
-    _perm: &mut RepoExclusive,
-) -> anyhow::Result<ProjectMeta> {
-    if !target_ref.as_bstr().starts_with_str("refs/remotes/") {
-        bail!(
-            "Default target must be a remote-tracking branch under refs/remotes, got '{}'",
-            target_ref.as_bstr()
-        );
-    }
-
-    let (target_ref, target_commit_id) = {
-        let repo = ctx.repo.get()?;
-        let mut target_reference = repo
-            .find_reference(target_ref)
-            .with_context(|| format!("Could not find target ref '{}'", target_ref.as_bstr()))?;
-        let target_ref_commit = target_reference
-            .peel_to_commit()
-            .with_context(|| {
-                format!(
-                    "Target ref '{}' does not point to a commit",
-                    target_ref.as_bstr()
-                )
-            })?
-            .id;
-        let current_head_commit = repo
-            .head()
-            .context("Failed to get HEAD reference")?
-            .peel_to_commit()
-            .context("Failed to peel HEAD reference to commit")?
-            .id;
-        let target_commit_id = repo
-            .merge_base(current_head_commit, target_ref_commit)
-            .with_context(|| {
-                format!(
-                    "Failed to calculate merge base between {current_head_commit} and {target_ref_commit}"
-                )
-            })?
-            .detach();
-        (target_ref.to_owned(), target_commit_id)
-    };
-
-    let mut project_meta = ctx.project_meta()?;
-    project_meta.target_ref = Some(target_ref);
-    project_meta.target_commit_id = Some(target_commit_id);
-    project_meta.push_remote = push_remote;
-    ctx.set_project_meta(project_meta.clone())?;
-    Ok(project_meta)
-}
-
 /// JSON transport types for branch APIs.
 pub mod json {
     use but_workspace::{branch::apply::OutcomeStatus, ui::ref_info::BranchReference};
@@ -1471,74 +1402,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn set_default_target_accepts_remote_tracking_ref_and_persists_metadata() -> anyhow::Result<()>
-    {
-        let (repo, _tmp) = repo_with_feature_branch()?;
-        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
-        let target_ref = gix::refs::FullName::try_from("refs/remotes/origin/main")?;
-
-        let project_meta =
-            super::set_default_target(&mut ctx, target_ref.as_ref(), Some("origin".into()))?;
-
-        let stored_meta = ctx.project_meta()?;
-        assert_eq!(project_meta, stored_meta);
-        assert_eq!(stored_meta.target_ref.as_ref(), Some(&target_ref));
-        assert!(stored_meta.target_commit_id.is_some());
-        assert_eq!(stored_meta.push_remote.as_deref(), Some("origin"));
-
-        Ok(())
-    }
-
-    #[test]
-    fn set_default_target_rejects_local_branch_refs() -> anyhow::Result<()> {
-        let (repo, _tmp) = repo_with_feature_branch()?;
-        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
-        let target_ref = gix::refs::FullName::try_from("refs/heads/feature")?;
-
-        let err = super::set_default_target(&mut ctx, target_ref.as_ref(), None)
-            .expect_err("local branches are not valid default targets");
-        assert_eq!(
-            err.to_string(),
-            "Default target must be a remote-tracking branch under refs/remotes, got 'refs/heads/feature'"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn set_default_target_uses_merge_base_not_target_tip() -> anyhow::Result<()> {
-        let (_repo, tmp) = repo_with_feature_branch()?;
-        git_at_dir(tmp.path()).args(["checkout", "feature"]).run();
-        write_file(tmp.path(), "feature.txt", "feature\n")?;
-        git_at_dir(tmp.path()).args(["add", "feature.txt"]).run();
-        git_at_dir(tmp.path())
-            .args(["commit", "-m", "feature"])
-            .run();
-        git_at_dir(tmp.path())
-            .args(["update-ref", "refs/remotes/origin/feature", "HEAD"])
-            .run();
-        git_at_dir(tmp.path()).args(["checkout", "main"]).run();
-
-        let repo = open_repo(tmp.path())?;
-        let target_ref = gix::refs::FullName::try_from("refs/remotes/origin/feature")?;
-        let target_tip = repo
-            .find_reference(target_ref.as_ref())?
-            .peel_to_id()?
-            .detach();
-        let current_head = repo.head_id()?.detach();
-        let expected_merge_base = repo.merge_base(current_head, target_tip)?.detach();
-        assert_ne!(expected_merge_base, target_tip);
-
-        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
-        let project_meta = super::set_default_target(&mut ctx, target_ref.as_ref(), None)?;
-
-        assert_eq!(project_meta.target_commit_id, Some(expected_merge_base));
-        assert_eq!(project_meta.push_remote, None);
-
-        Ok(())
-    }
-
     #[test]
     fn checkout_branch_switches_head_and_returns_workspace() -> anyhow::Result<()> {
         let (repo, _tmp) = repo_with_feature_branch()?;
diff --git a/crates/but-api/src/workspace.rs b/crates/but-api/src/workspace.rs
index aa3c193b1f2..07d0892a5f3 100644
--- a/crates/but-api/src/workspace.rs
+++ b/crates/but-api/src/workspace.rs
@@ -31,6 +31,39 @@ pub fn get_workspace(
         .map(Into::into)
 }
 
+/// Make `target_ref` the project's default target without applying branches or entering
+/// managed workspace mode.
+///
+/// This acquires exclusive worktree access from `ctx` before updating project metadata.
+/// See [`but_workspace::init::set_target_ref_and_init_project()`] for details; notably the
+/// target commit id is only computed when it wasn't set before, and an omitted
+/// `push_remote` keeps the currently configured one. It deliberately records no oplog
+/// snapshot - only project metadata changes, no repository state.
+#[cfg(feature = "legacy")]
+#[but_api(napi)]
+#[instrument(err(Debug))]
+pub fn set_target_ref_and_init_project(
+    ctx: &mut but_ctx::Context,
+    target_ref: &gix::refs::FullNameRef,
+    push_remote: Option<String>,
+) -> anyhow::Result<()> {
+    let mut guard = ctx.exclusive_worktree_access();
+    {
+        let repo = ctx.repo.get()?;
+        let mut meta = ctx.meta()?;
+        but_workspace::init::set_target_ref_and_init_project(
+            &repo,
+            &mut meta,
+            target_ref,
+            push_remote,
+        )?;
+    }
+    ctx.invalidate_workspace_cache()?;
+    crate::legacy::meta::reconcile_in_workspace_state_of_vb_toml(ctx, guard.write_permission())
+        .ok();
+    Ok(())
+}
+
 /// Result of integrating upstream changes into the current workspace.
 #[derive(Debug, Clone)]
 pub struct WorkspaceIntegrateUpstreamOutcome {
@@ -358,7 +391,109 @@ pub fn workspace_integrate_upstream_only_with_perm(
 #[cfg(test)]
 mod tests {
     use super::{review_integration_hints_from_reviews, target_branch_name};
+    use but_testsupport::{CommandExt, git_at_dir, open_repo};
     use std::collections::HashSet;
+    use std::path::Path;
+
+    fn repo_with_feature_branch() -> anyhow::Result<(gix::Repository, tempfile::TempDir)> {
+        let tmp = tempfile::tempdir()?;
+        git_at_dir(tmp.path()).args(["init"]).run();
+        git_at_dir(tmp.path())
+            .args(["config", "user.name", "GitButler"])
+            .run();
+        git_at_dir(tmp.path())
+            .args(["config", "user.email", "gitbutler@example.com"])
+            .run();
+        write_file(tmp.path(), "file.txt", "one\n")?;
+        git_at_dir(tmp.path()).args(["add", "file.txt"]).run();
+        git_at_dir(tmp.path()).args(["commit", "-m", "one"]).run();
+        git_at_dir(tmp.path()).args(["branch", "feature"]).run();
+        git_at_dir(tmp.path())
+            .args(["config", "remote.origin.url", "../origin"])
+            .run();
+        git_at_dir(tmp.path())
+            .args(["update-ref", "refs/remotes/origin/main", "HEAD"])
+            .run();
+        write_file(tmp.path(), "file.txt", "two\n")?;
+        git_at_dir(tmp.path()).args(["commit", "-am", "two"]).run();
+
+        Ok((open_repo(tmp.path())?, tmp))
+    }
+
+    fn write_file(root: &Path, relative_path: &str, content: &str) -> anyhow::Result<()> {
+        std::fs::write(root.join(relative_path), content)?;
+        Ok(())
+    }
+
+    #[test]
+    fn set_target_ref_accepts_remote_tracking_ref_and_persists_metadata() -> anyhow::Result<()> {
+        let (repo, _tmp) = repo_with_feature_branch()?;
+        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
+        let target_ref = gix::refs::FullName::try_from("refs/remotes/origin/main")?;
+
+        super::set_target_ref_and_init_project(
+            &mut ctx,
+            target_ref.as_ref(),
+            Some("origin".into()),
+        )?;
+
+        let stored_meta = ctx.project_meta()?;
+        assert_eq!(stored_meta.target_ref.as_ref(), Some(&target_ref));
+        assert!(stored_meta.target_commit_id.is_some());
+        assert_eq!(stored_meta.push_remote.as_deref(), Some("origin"));
+
+        Ok(())
+    }
+
+    #[test]
+    fn set_target_ref_rejects_local_branch_refs() -> anyhow::Result<()> {
+        let (repo, _tmp) = repo_with_feature_branch()?;
+        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
+        let target_ref = gix::refs::FullName::try_from("refs/heads/feature")?;
+
+        let err = super::set_target_ref_and_init_project(&mut ctx, target_ref.as_ref(), None)
+            .expect_err("local branches are not valid default targets");
+        assert_eq!(
+            err.to_string(),
+            "target ref 'refs/heads/feature' must be a remote tracking branch"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn set_target_ref_uses_merge_base_not_target_tip() -> anyhow::Result<()> {
+        let (_repo, tmp) = repo_with_feature_branch()?;
+        git_at_dir(tmp.path()).args(["checkout", "feature"]).run();
+        write_file(tmp.path(), "feature.txt", "feature\n")?;
+        git_at_dir(tmp.path()).args(["add", "feature.txt"]).run();
+        git_at_dir(tmp.path())
+            .args(["commit", "-m", "feature"])
+            .run();
+        git_at_dir(tmp.path())
+            .args(["update-ref", "refs/remotes/origin/feature", "HEAD"])
+            .run();
+        git_at_dir(tmp.path()).args(["checkout", "main"]).run();
+
+        let repo = open_repo(tmp.path())?;
+        let target_ref = gix::refs::FullName::try_from("refs/remotes/origin/feature")?;
+        let target_tip = repo
+            .find_reference(target_ref.as_ref())?
+            .peel_to_id()?
+            .detach();
+        let current_head = repo.head_id()?.detach();
+        let expected_merge_base = repo.merge_base(current_head, target_tip)?.detach();
+        assert_ne!(expected_merge_base, target_tip);
+
+        let mut ctx = but_ctx::Context::from_repo_for_testing(repo)?.with_memory_app_cache();
+        super::set_target_ref_and_init_project(&mut ctx, target_ref.as_ref(), None)?;
+
+        let project_meta = ctx.project_meta()?;
+        assert_eq!(project_meta.target_commit_id, Some(expected_merge_base));
+        assert_eq!(project_meta.push_remote, None);
+
+        Ok(())
+    }
 
     fn review(
         sha: &str,
diff --git a/crates/but-core/src/ref_metadata.rs b/crates/but-core/src/ref_metadata.rs
index d99ac27f3af..4ee4f9ae6b4 100644
--- a/crates/but-core/src/ref_metadata.rs
+++ b/crates/but-core/src/ref_metadata.rs
@@ -568,6 +568,25 @@ impl ProjectMeta {
         Ok(Self::is_ported(&config))
     }
 
+    /// Persist project metadata to the repository-local Git config of `repo` and back-fill
+    /// the legacy workspace metadata in `meta`, repairing partially migrated target
+    /// information first.
+    ///
+    /// Returns the metadata as persisted. Callers that cache workspace projections must
+    /// invalidate them afterwards.
+    pub fn persist(
+        self,
+        repo: &gix::Repository,
+        meta: &mut impl crate::RefMetadata,
+    ) -> anyhow::Result<Self> {
+        let project_meta = repair_target_metadata_for_migration(&self, repo);
+        project_meta.persist_to_local_config(repo)?;
+        let mut workspace = meta.workspace(crate::WORKSPACE_REF_NAME.try_into()?)?;
+        workspace.set_project_meta(project_meta.clone());
+        meta.set_workspace(&workspace)?;
+        Ok(project_meta)
+    }
+
     /// Persist project metadata to repository-local Git config and mark it as ported.
     pub fn persist_to_local_config(&self, repo: &gix::Repository) -> anyhow::Result<()> {
         let project_meta = repair_target_metadata_for_migration(self, repo);
diff --git a/crates/but-ctx/src/lib.rs b/crates/but-ctx/src/lib.rs
index f5a33be41ca..6724c5591f8 100644
--- a/crates/but-ctx/src/lib.rs
+++ b/crates/but-ctx/src/lib.rs
@@ -10,7 +10,7 @@ use std::{
 
 use anyhow::anyhow;
 use but_core::{
-    RefMetadata as _, RepositoryExt, WORKSPACE_REF_NAME,
+    RepositoryExt,
     ref_metadata::ProjectMeta,
     sync::{RepoExclusive, RepoExclusiveGuard, RepoShared, RepoSharedGuard},
 };
@@ -818,17 +818,11 @@ impl Context {
     /// Note that the cached repository handle needs no reload: [`Self::project_meta()`]
     /// re-reads the on-disk configuration on every call.
     pub fn set_project_meta(&self, project_meta: ProjectMeta) -> anyhow::Result<()> {
-        let project_meta = {
+        {
             let repo = self.repo.get()?;
-            let project_meta =
-                but_core::ref_metadata::repair_target_metadata_for_migration(&project_meta, &repo);
-            project_meta.persist_to_local_config(&repo)?;
-            project_meta
-        };
-        let mut meta = self.meta()?;
-        let mut workspace = meta.workspace(WORKSPACE_REF_NAME.try_into()?)?;
-        workspace.set_project_meta(project_meta);
-        meta.set_workspace(&workspace)?;
+            let mut meta = self.meta()?;
+            project_meta.persist(&repo, &mut meta)?;
+        }
         self.invalidate_workspace_cache()?;
         Ok(())
     }
diff --git a/crates/but-server/src/lib.rs b/crates/but-server/src/lib.rs
index 3117e804a36..818718c2fbc 100644
--- a/crates/but-server/src/lib.rs
+++ b/crates/but-server/src/lib.rs
@@ -546,6 +546,10 @@ pub async fn run(config: Config) -> anyhow::Result<()> {
         )
         .route("/branch_diff", but_post(but_api::branch::branch_diff_cmd))
         .route("/move_branch", but_post(but_api::branch::move_branch_cmd))
+        .route(
+            "/set_target_ref_and_init_project",
+            but_post(workspace::set_target_ref_and_init_project_cmd),
+        )
         .route("/apply", but_post(but_api::branch::apply_cmd))
         .route("/review_apply", but_post(legacy::forge::review_apply_cmd))
         .route(
diff --git a/crates/but-workspace/src/init.rs b/crates/but-workspace/src/init.rs
new file mode 100644
index 00000000000..6e419369771
--- /dev/null
+++ b/crates/but-workspace/src/init.rs
@@ -0,0 +1,129 @@
+//! Project initialization: set the default target without entering the managed workspace.
+//!
+//! This is the replacement for the legacy `set_base_branch()`, which coupled setting the
+//! target with moving the user onto `refs/heads/gitbutler/workspace`. Now that the
+//! application can operate on any branch, the target can be set at any time.
+
+use anyhow::{Context as _, Result, bail};
+use but_core::{
+    RefMetadata,
+    git_config::{edit_repo_config, ensure_config_value},
+    ref_metadata::ProjectMeta,
+};
+
+/// Make `target_ref` the project's default target and initialize project metadata,
+/// without changing the currently checked out branch.
+///
+/// This performs the metadata-only parts of the legacy `set_base_branch()`:
+///
+/// * repair partially migrated target metadata and persist it if it changed,
+/// * store the target as [`ProjectMeta`] via [`ProjectMeta::persist()`], which also
+///   back-fills the legacy metadata in `meta`,
+/// * set `log.excludeDecoration = refs/gitbutler` in the repository-local Git config.
+///
+/// The target commit id is only computed - as the merge-base between `HEAD` and
+/// `target_ref` - if it isn't already set; an existing value is never overwritten.
+/// `push_remote`, if `Some`, is validated and stored; if `None`, an existing push remote
+/// is kept as is.
+///
+/// Unlike `set_base_branch()`, this neither creates stacks, nor updates the workspace
+/// commit, nor checks anything out. The caller is expected to hold exclusive worktree
+/// access, and to invalidate any cached workspace projection afterwards.
+pub fn set_target_ref_and_init_project(
+    repo: &gix::Repository,
+    meta: &mut impl RefMetadata,
+    target_ref: &gix::refs::FullNameRef,
+    push_remote: Option<String>,
+) -> Result<()> {
+    let project_meta = match ProjectMeta::resolve(repo, &*meta) {
+        Ok(project_meta) => {
+            let repaired =
+                but_core::ref_metadata::repair_target_metadata_for_migration(&project_meta, repo);
+            if repaired != project_meta {
+                repaired.clone().persist(repo, meta)?;
+            }
+            Some(repaired)
+        }
+        Err(_) => None,
+    };
+
+    if target_ref.category() != Some(gix::refs::Category::RemoteBranch) {
+        bail!(
+            "target ref '{}' must be a remote tracking branch",
+            target_ref.as_bstr()
+        );
+    }
+
+    let target_head = repo
+        .try_find_reference(target_ref)?
+        .with_context(|| format!("remote branch '{}' not found", target_ref.as_bstr()))?
+        .peel_to_commit()
+        .with_context(|| format!("failed to peel branch '{}' to commit", target_ref.as_bstr()))?
+        .id;
+
+    // Reject targets whose remote isn't configured - reads like the base-branch data
+    // would fail on them later.
+    let remote_names = repo.remote_names();
+    let (remote_name, _short_name) =
+        but_core::extract_remote_name_and_short_name(target_ref, &remote_names).with_context(
+            || {
+                format!(
+                    "failed to determine remote for branch '{}'",
+                    target_ref.as_bstr()
+                )
+            },
+        )?;
+    repo.find_remote(remote_name.as_str())
+        .with_context(|| {
+            format!(
+                "failed to find remote for branch '{}'",
+                target_ref.as_bstr()
+            )
+        })?
+        .url(gix::remote::Direction::Fetch)
+        .with_context(|| format!("failed to get remote url for '{remote_name}'"))?;
+
+    let sha = match project_meta.as_ref().and_then(|meta| meta.target_commit_id) {
+        Some(existing) => existing,
+        None => {
+            let head_commit = repo
+                .head()
+                .context("Failed to get HEAD reference")?
+                .peel_to_commit()
+                .context("Failed to peel HEAD reference to commit")?
+                .id;
+            repo.merge_base(head_commit, target_head)
+                .with_context(|| {
+                    format!(
+                        "Failed to calculate merge base between {head_commit} and {target_head}"
+                    )
+                })?
+                .detach()
+        }
+    };
+
+    let push_remote = match push_remote {
+        Some(name) => {
+            repo.find_remote(name.as_str())
+                .with_context(|| format!("failed to find remote {name}"))?;
+            Some(name)
+        }
+        // Unlike the legacy `set_base_branch()`, keep an existing push remote instead of
+        // clearing it - the target may be (re-)set at any time.
+        None => project_meta.and_then(|meta| meta.push_remote),
+    };
+
+    ProjectMeta {
+        target_ref: Some(target_ref.to_owned()),
+        target_commit_id: Some(sha),
+        push_remote,
+    }
+    .persist(repo, meta)?;
+
+    edit_repo_config(repo, gix::config::Source::Local, |config| {
+        ensure_config_value(config, "log.excludeDecoration", "refs/gitbutler")
+            .context("failed to set log.excludeDecoration")?;
+        Ok(())
+    })?;
+    Ok(())
+}
diff --git a/crates/but-workspace/src/lib.rs b/crates/but-workspace/src/lib.rs
index 60d5a12b316..cb29e21be0f 100644
--- a/crates/but-workspace/src/lib.rs
+++ b/crates/but-workspace/src/lib.rs
@@ -30,6 +30,8 @@ use but_core::DiffSpec;
 #[cfg(feature = "legacy")]
 pub mod legacy;
 
+pub mod init;
+
 /// Types specifically for the user-interface.
 pub mod ui;
 
diff --git a/crates/but-workspace/tests/fixtures/scenario/init-project-with-origin.sh b/crates/but-workspace/tests/fixtures/scenario/init-project-with-origin.sh
new file mode 100755
index 00000000000..81ac945a9bb
--- /dev/null
+++ b/crates/but-workspace/tests/fixtures/scenario/init-project-with-origin.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+### Description
+# A local repository with a single commit on `main`, pushed to an `origin` remote
+# so `refs/remotes/origin/main` exists. No workspace, no target - the starting
+# point for initializing a project.
+
+set -eu -o pipefail
+
+source "${BASH_SOURCE[0]%/*}/shared.sh"
+
+git init --bare remote.git
+git init
+commit M
+git remote add origin ./remote.git
+# A second remote so tests can tell a preserved push remote apart from one
+# defaulted to the target's remote.
+git remote add fork ./remote.git
+git push --quiet -u origin main
diff --git a/crates/but-workspace/tests/workspace/init.rs b/crates/but-workspace/tests/workspace/init.rs
new file mode 100644
index 00000000000..c8e0e2dd2bc
--- /dev/null
+++ b/crates/but-workspace/tests/workspace/init.rs
@@ -0,0 +1,303 @@
+//! Tests for [`but_workspace::init::set_target_ref_and_init_project()`], the metadata-only
+//! replacement for the legacy `set_base_branch()`.
+
+use but_core::git_config::{edit_config, set_config_value};
+use but_core::ref_metadata::ProjectMeta;
+use but_meta::VirtualBranchesTomlMetadata;
+use gix::refs::transaction::PreviousValue;
+
+use crate::utils::writable_scenario;
+
+fn scenario() -> (
+    gix::Repository,
+    VirtualBranchesTomlMetadata,
+    but_testsupport::gix_testtools::tempfile::TempDir,
+) {
+    let (repo, tmp) = writable_scenario("init-project-with-origin");
+    let meta = VirtualBranchesTomlMetadata::from_path(repo.path().join("virtual-branches.toml"))
+        .expect("toml metadata opens in fixture repositories");
+    (repo, meta, tmp)
+}
+
+fn set_target_ref(
+    repo: &gix::Repository,
+    meta: &mut VirtualBranchesTomlMetadata,
+    target_ref: &str,
+    push_remote: Option<&str>,
+) -> anyhow::Result<()> {
+    let target_ref: gix::refs::FullName = target_ref.try_into()?;
+    but_workspace::init::set_target_ref_and_init_project(
+        repo,
+        meta,
+        target_ref.as_ref(),
+        push_remote.map(ToOwned::to_owned),
+    )
+}
+
+fn stored_meta(repo: &gix::Repository, meta: &VirtualBranchesTomlMetadata) -> ProjectMeta {
+    ProjectMeta::resolve(repo, meta).expect("project metadata is readable")
+}
+
+/// Create an empty commit on top of `parent` without updating any reference.
+fn empty_commit_on_top(
+    repo: &gix::Repository,
+    parent: gix::ObjectId,
+    message: &str,
+) -> gix::ObjectId {
+    let tree = repo
+        .find_commit(parent)
+        .expect("parent commit exists")
+        .tree_id()
+        .expect("commit has a tree")
+        .detach();
+    let signature = gix::actor::Signature {
+        name: "test".into(),
+        email: "test@example.com".into(),
+        time: gix::date::Time::new(1675176957, 0),
+    };
+    let commit = gix::objs::Commit {
+        tree,
+        parents: [parent].into(),
+        author: signature.clone(),
+        committer: signature,
+        encoding: None,
+        message: message.into(),
+        extra_headers: Vec::new(),
+    };
+    repo.write_object(&commit)
+        .expect("commit can be written")
+        .detach()
+}
+
+#[test]
+fn fresh_init_sets_target_and_keeps_current_branch() {
+    let (repo, mut meta, _tmp) = scenario();
+    let head_name_before = repo.head_name().unwrap().unwrap();
+    let head_commit = repo.head_id().unwrap().detach();
+
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", None).unwrap();
+
+    let project_meta = stored_meta(&repo, &meta);
+    assert_eq!(
+        project_meta.target_ref.map(|name| name.to_string()),
+        Some("refs/remotes/origin/main".to_string())
+    );
+    assert_eq!(
+        project_meta.target_commit_id,
+        Some(head_commit),
+        "with no stored id, the merge-base is used - here HEAD and the target share their only commit"
+    );
+
+    // Re-open to observe ref and configuration changes.
+    let repo = but_testsupport::open_repo(repo.workdir().expect("fixture has a worktree")).unwrap();
+    assert_eq!(
+        repo.head_name().unwrap().unwrap(),
+        head_name_before,
+        "the user stays on their current branch"
+    );
+    assert!(
+        repo.try_find_reference("refs/heads/gitbutler/workspace")
+            .unwrap()
+            .is_none(),
+        "no workspace reference is created"
+    );
+    assert_eq!(
+        repo.config_snapshot()
+            .string("log.excludeDecoration")
+            .map(|value| value.to_string()),
+        Some("refs/gitbutler".to_string()),
+        "initialization hides GitButler refs from log decorations, like the legacy path did"
+    );
+}
+
+#[test]
+fn resetting_the_same_ref_keeps_the_target_commit_id() {
+    let (repo, mut meta, _tmp) = scenario();
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", None).unwrap();
+    let initial_target_id = stored_meta(&repo, &meta).target_commit_id.unwrap();
+
+    // Advance both the local branch and the remote-tracking ref so a recomputed
+    // merge-base would differ from the stored one.
+    let new_commit = empty_commit_on_top(&repo, repo.head_id().unwrap().detach(), "advance");
+    repo.reference("refs/heads/main", new_commit, PreviousValue::Any, "test")
+        .unwrap();
+    repo.reference(
+        "refs/remotes/origin/main",
+        new_commit,
+        PreviousValue::Any,
+        "test",
+    )
+    .unwrap();
+
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", None).unwrap();
+    assert_eq!(
+        stored_meta(&repo, &meta).target_commit_id,
+        Some(initial_target_id),
+        "an existing target commit id is never overwritten"
+    );
+}
+
+#[test]
+fn changing_the_target_ref_preserves_the_target_commit_id() {
+    let (repo, mut meta, _tmp) = scenario();
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", None).unwrap();
+    let initial_target_id = stored_meta(&repo, &meta).target_commit_id.unwrap();
+
+    // Advance the local branch and create the new target at the new commit so a
+    // recomputed merge-base with the new target would differ from the stored one.
+    let new_commit = empty_commit_on_top(&repo, repo.head_id().unwrap().detach(), "advance");
+    repo.reference("refs/heads/main", new_commit, PreviousValue::Any, "test")
+        .unwrap();
+    repo.reference(
+        "refs/remotes/origin/other",
+        new_commit,
+        PreviousValue::Any,
+        "test",
+    )
+    .unwrap();
+
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/other", None).unwrap();
+
+    let project_meta = stored_meta(&repo, &meta);
+    assert_eq!(
+        project_meta.target_ref.map(|name| name.to_string()),
+        Some("refs/remotes/origin/other".to_string())
+    );
+    assert_eq!(
+        project_meta.target_commit_id,
+        Some(initial_target_id),
+        "the stored id is kept verbatim even for a different target branch"
+    );
+}
+
+#[test]
+fn fills_missing_target_commit_id_from_existing_target_ref() {
+    let (repo, mut meta, _tmp) = scenario();
+    let target_ref = "refs/remotes/origin/main";
+
+    // Write the partially migrated state - target ref present, commit id missing -
+    // directly to the local Git configuration, as a metadata write would already
+    // repair it. The repair in `set_target_ref_and_init_project()` is what has to
+    // fill the missing commit id.
+    edit_config(Some(&repo), gix::config::Source::Local, |config| {
+        set_config_value(config, "gitbutler.project.targetRef", target_ref)?;
+        set_config_value(config, "gitbutler.project.portedMeta", "true")?;
+        Ok(())
+    })
+    .unwrap();
+
+    // Advance only the remote-tracking ref, leaving `HEAD` behind, so the target tip
+    // (which migration repair fills in) differs from `merge_base(HEAD, target)`
+    // (which the fresh-init fallback would compute).
+    let old_tip = repo
+        .find_reference(target_ref)
+        .unwrap()
+        .peel_to_commit()
+        .unwrap()
+        .id;
+    let new_target_tip = empty_commit_on_top(&repo, old_tip, "advance target");
+    repo.reference(target_ref, new_target_tip, PreviousValue::Any, "test")
+        .unwrap();
+
+    set_target_ref(&repo, &mut meta, target_ref, None).unwrap();
+
+    assert_eq!(
+        stored_meta(&repo, &meta).target_commit_id,
+        Some(new_target_tip),
+        "a missing id is filled from the stored target ref's tip, not the merge-base"
+    );
+}
+
+#[test]
+fn push_remote_is_set_and_preserved_when_omitted() {
+    let (repo, mut meta, _tmp) = scenario();
+
+    // 'fork' deliberately differs from the target's own remote so preservation
+    // can't be confused with defaulting to the target's remote.
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", Some("fork")).unwrap();
+    assert_eq!(
+        stored_meta(&repo, &meta).push_remote.as_deref(),
+        Some("fork")
+    );
+
+    // Unlike the legacy `set_base_branch()`, omitting the push remote keeps it.
+    set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", None).unwrap();
+    assert_eq!(
+        stored_meta(&repo, &meta).push_remote.as_deref(),
+        Some("fork"),
+        "the existing push remote is preserved, not replaced by the target's remote"
+    );
+}
+
+mod error {
+    use super::*;
+
+    #[test]
+    fn missing_remote_branch() {
+        let (repo, mut meta, _tmp) = scenario();
+        assert_eq!(
+            set_target_ref(&repo, &mut meta, "refs/remotes/origin/missing", None)
+                .unwrap_err()
+                .to_string(),
+            "remote branch 'refs/remotes/origin/missing' not found"
+        );
+    }
+
+    #[test]
+    fn local_branch_rejected() {
+        let (repo, mut meta, _tmp) = scenario();
+        assert_eq!(
+            set_target_ref(&repo, &mut meta, "refs/heads/main", None)
+                .unwrap_err()
+                .to_string(),
+            "target ref 'refs/heads/main' must be a remote tracking branch"
+        );
+    }
+
+    #[test]
+    fn unknown_push_remote() {
+        let (repo, mut meta, _tmp) = scenario();
+        assert_eq!(
+            set_target_ref(&repo, &mut meta, "refs/remotes/origin/main", Some("nope"))
+                .unwrap_err()
+                .to_string(),
+            "failed to find remote nope"
+        );
+    }
+
+    #[test]
+    fn remote_without_fetch_url_rejected() {
+        let (repo, mut meta, _tmp) = scenario();
+
+        // A remote that exists (has a push URL and refspecs) but has no fetch URL.
+        // Accepting it would break every later base-branch read, which derives the
+        // fetch URL on demand.
+        edit_config(Some(&repo), gix::config::Source::Local, |config| {
+            set_config_value(config, "remote.pushonly.pushUrl", "./remote.git")?;
+            set_config_value(
+                config,
+                "remote.pushonly.fetch",
+                "+refs/heads/*:refs/remotes/pushonly/*",
+            )?;
+            Ok(())
+        })
+        .unwrap();
+        let head_id = repo.head_id().unwrap().detach();
+        repo.reference(
+            "refs/remotes/pushonly/main",
+            head_id,
+            PreviousValue::Any,
+            "test",
+        )
+        .unwrap();
+
+        let repo =
+            but_testsupport::open_repo(repo.workdir().expect("fixture has a worktree")).unwrap();
+        assert_eq!(
+            set_target_ref(&repo, &mut meta, "refs/remotes/pushonly/main", None)
+                .unwrap_err()
+                .to_string(),
+            "failed to get remote url for 'pushonly'"
+        );
+    }
+}
diff --git a/crates/but-workspace/tests/workspace/main.rs b/crates/but-workspace/tests/workspace/main.rs
index 86fae6f742f..7b71eec5a3b 100644
--- a/crates/but-workspace/tests/workspace/main.rs
+++ b/crates/but-workspace/tests/workspace/main.rs
@@ -5,6 +5,7 @@ mod branch_details;
 mod commit;
 mod flatten_diff_specs;
 mod graph;
+mod init;
 mod push;
 mod ref_info;
 mod shallow_clone;
diff --git a/crates/gitbutler-operating-modes/src/lib.rs b/crates/gitbutler-operating-modes/src/lib.rs
index 3fe04b08722..56936aac4b2 100644
--- a/crates/gitbutler-operating-modes/src/lib.rs
+++ b/crates/gitbutler-operating-modes/src/lib.rs
@@ -165,28 +165,40 @@ fn outside_workspace_metadata(
         .referent_name()
         .map(|r| r.as_partial_name().as_bstr().to_owned());
 
+    // A failed conflict computation must not degrade the metadata to an empty
+    // default - the branch name is what the UI needs to describe HEAD, e.g. in
+    // single-branch mode without a target or a workspace commit.
+    let worktree_conflicts = worktree_conflicts_with_workspace(ctx, perm, &gix_repo)
+        .unwrap_or_else(|err| {
+            tracing::warn!("Failed to compute worktree conflicts with the workspace: {err}");
+            vec![]
+        });
+
+    Ok(OutsideWorkspaceMetadata {
+        branch_name,
+        worktree_conflicts,
+    })
+}
+
+fn worktree_conflicts_with_workspace(
+    ctx: &Context,
+    perm: &RepoShared,
+    gix_repo: &gix::Repository,
+) -> Result<Vec<BStringForFrontend>> {
     let (_repo, ws, _db) = ctx.workspace_and_db_with_perm(perm)?;
     if ws.target_ref.is_none() || ws.stacks.is_empty() {
         // Nothing to conflict
-        return Ok(OutsideWorkspaceMetadata {
-            branch_name,
-            worktree_conflicts: vec![],
-        });
+        return Ok(vec![]);
     }
 
     let (outcome, conflict_kind) =
-        but_workspace::legacy::merge_worktree_with_workspace(ctx, &gix_repo)?;
-    let worktree_conflicts = outcome
+        but_workspace::legacy::merge_worktree_with_workspace(ctx, gix_repo)?;
+    Ok(outcome
         .conflicts
         .iter()
         .filter(|c| c.is_unresolved(conflict_kind))
         .map(|c| c.ours.location().into())
-        .collect::<Vec<BStringForFrontend>>();
-
-    Ok(OutsideWorkspaceMetadata {
-        branch_name,
-        worktree_conflicts,
-    })
+        .collect())
 }
 
 pub fn in_open_workspace_mode(ctx: &Context, perm: &RepoShared) -> Result<bool> {
diff --git a/crates/gitbutler-tauri/src/main.rs b/crates/gitbutler-tauri/src/main.rs
index 68434de54ad..ed867f2856a 100644
--- a/crates/gitbutler-tauri/src/main.rs
+++ b/crates/gitbutler-tauri/src/main.rs
@@ -313,6 +313,7 @@ fn main() -> anyhow::Result<()> {
                 diff::tauri_commit_details::commit_details,
                 diff::tauri_commit_details_with_line_stats::commit_details_with_line_stats,
                 workspace::tauri_get_workspace::get_workspace,
+                workspace::tauri_set_target_ref_and_init_project::set_target_ref_and_init_project,
                 but_api::branch::tauri_branch_diff::branch_diff,
                 but_api::branch::tauri_move_branch::move_branch,
                 but_api::branch::tauri_tear_off_branch::tear_off_branch,
diff --git a/e2e/playwright/src/branch.ts b/e2e/playwright/src/branch.ts
index 8e3e8bc1f45..8bf33e36766 100644
--- a/e2e/playwright/src/branch.ts
+++ b/e2e/playwright/src/branch.ts
@@ -97,6 +97,38 @@ export async function assertDirtyWorktree(pathToRepo: string): Promise<void> {
 		.not.toBe("");
 }
 
+export async function assertRefDoesNotExist(refName: string, pathToRepo: string): Promise<void> {
+	await expect
+		.poll(() => git(pathToRepo, ["for-each-ref", "--format=%(refname)", refName]), {
+			message: `Expected ref "${refName}" to not exist`,
+			intervals: [100, 200, 500, 1000],
+		})
+		.toBe("");
+}
+
+export async function assertGitConfigValue(
+	key: string,
+	value: string,
+	pathToRepo: string,
+): Promise<void> {
+	await expect
+		.poll(
+			() => {
+				try {
+					return git(pathToRepo, ["config", "--local", key]);
+				} catch {
+					// `git config` exits non-zero while the key is not set yet.
+					return "<unset>";
+				}
+			},
+			{
+				message: `Expected git config "${key}" to be "${value}"`,
+				intervals: [100, 200, 500, 1000],
+			},
+		)
+		.toBe(value);
+}
+
 export function currentBranch(pathToRepo: string): string {
 	return git(pathToRepo, ["branch", "--show-current"]);
 }
diff --git a/e2e/playwright/tests/singleBranch/addingAProject.spec.ts b/e2e/playwright/tests/singleBranch/addingAProject.spec.ts
new file mode 100644
index 00000000000..282d8df0e71
--- /dev/null
+++ b/e2e/playwright/tests/singleBranch/addingAProject.spec.ts
@@ -0,0 +1,61 @@
+import { expectCurrentBranchChip } from "./helpers.ts";
+import {
+	assertBranch,
+	assertCommitSubjects,
+	assertDirtyWorktree,
+	assertGitConfigValue,
+	assertRefDoesNotExist,
+} from "../../src/branch.ts";
+import { gotoOnboarding } from "../../src/setup.ts";
+import { test } from "../../src/test.ts";
+import { clickByTestId, getByTestId, mockPickDirectory, waitForTestId } from "../../src/util.ts";
+import { expect } from "@playwright/test";
+
+test.use({
+	gitbutlerOptions: {
+		config: {
+			onboardingComplete: true,
+			featureFlags: { singleBranch: true },
+		},
+	},
+});
+
+// The single-branch counterpart of the onboarding test in ../addingAProject.spec.ts:
+// setting the target must only write project metadata, leaving the user on the branch
+// they were on instead of moving them onto gitbutler/workspace.
+test("adding a project sets the target without leaving the checked out branch", async ({
+	page,
+	gitbutler,
+}) => {
+	const projectPath = gitbutler.pathInWorkdir("local-with-changes/");
+	await gitbutler.runScript("project-with-commit-and-uncommitted-changes.sh");
+	await gotoOnboarding(page);
+
+	await mockPickDirectory(page, projectPath);
+	await clickByTestId(page, "add-local-project");
+	await waitForTestId(page, "project-setup-page");
+
+	// The setup page must not promise the branch switch the flag turns off.
+	await expect(page.getByText(/GitButler switches your active branch/)).toHaveCount(0);
+
+	await clickByTestId(page, "set-base-branch");
+	await waitForTestId(page, "workspace-view");
+
+	// The user is still on master with their uncommitted changes; no workspace
+	// branch was created or checked out, and no workspace commit was made.
+	await assertBranch("master", projectPath);
+	await expectCurrentBranchChip(page, "master");
+	await assertDirtyWorktree(projectPath);
+	await assertRefDoesNotExist("refs/heads/gitbutler/workspace", projectPath);
+	await assertCommitSubjects(["Second commit on main branch", "Initial commit"], projectPath);
+
+	// The target itself was configured, just without entering the workspace.
+	await assertGitConfigValue(
+		"gitbutler.project.targetRef",
+		"refs/remotes/origin/master",
+		projectPath,
+	);
+
+	// Entering the managed workspace stays available as an explicit action.
+	await expect(getByTestId(page, "chrome-header-switch-back-to-workspace-button")).toBeVisible();
+});
diff --git a/packages/but-sdk/src/generated/graph/index.d.ts b/packages/but-sdk/src/generated/graph/index.d.ts
index 2960c2d4612..6f93236b4da 100644
--- a/packages/but-sdk/src/generated/graph/index.d.ts
+++ b/packages/but-sdk/src/generated/graph/index.d.ts
@@ -473,6 +473,18 @@ export declare function setReviewDraftiness(projectId: string, reviewId: number,
  */
 export declare function setReviewTemplate(projectId: string, templatePath: string | null): Promise<void>
 
+/**
+ * Make `target_ref` the project's default target without applying branches or entering
+ * managed workspace mode.
+ *
+ * This acquires exclusive worktree access from `ctx` before updating project metadata.
+ * See [`but_workspace::init::set_target_ref_and_init_project()`] for details; notably the
+ * target commit id is only computed when it wasn't set before, and an omitted
+ * `push_remote` keeps the currently configured one. It deliberately records no oplog
+ * snapshot - only project metadata changes, no repository state.
+ */
+export declare function setTargetRefAndInitProject(projectId: string, targetRef: string, pushRemote: string | null): Promise<void>
+
 /**
  * Tears off a branch using the behavior described by [`tear_off_branch_with_perm()`].
  *
diff --git a/packages/but-sdk/src/generated/graph/index.js b/packages/but-sdk/src/generated/graph/index.js
index 20fb755379d..ac17f9c7e21 100644
--- a/packages/but-sdk/src/generated/graph/index.js
+++ b/packages/but-sdk/src/generated/graph/index.js
@@ -579,7 +579,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { absorb, absorptionPlan, apply, applyBranchIntegration, assignHunk, branchCheckout, branchCheckoutNew, branchCreate, branchDetails, branchDiff, branchLand, branchRemove, changesInWorktree, changesInWorktreeWithPerm, commitAmend, commitCreate, commitDetailsWithLineStats, commitDiscard, commitDiscardChanges, commitInsertBlank, commitMove, commitMoveChangesBetween, commitReword, commitSquash, commitUncommit, commitUncommitChanges, commitUncommitChangesFromCommits, discardWorktreeChanges, forgeCompareBranchUrl, forgeInfo, forgeProvider, getInitialBranchIntegration, getRedoTargetSnapshot, getRepoInfo, getReview, getReviewBaseRepoUrl, getReviewMergeStatus, getUndoTargetSnapshot, getWorkspace, headInfo, initApplicationNamespace, listAvailableReviewTemplates, listBranches, listCiChecks, listEditors, listProjectsStateless, listReviews, listReviewsForBranch, mergeReview, moveBranch, openInEditor, peelRestoreSnapshot, publishReview, pushStack, removeBranch, restoreSnapshotWithKind, reviewApply, reviewTemplate, setReviewAutoMerge, setReviewDraftiness, setReviewTemplate, tearOffBranch, treeChangeDiffs, unapplyStack, updateBranchName, updateReview, updateReviewFooters, warmCiChecksCache, workspaceBranchAndAncestorsPush, workspaceCheckout, workspaceIntegrateUpstream, WatcherHandle, ANY_FORK, ANY_FORK_OR_MERGE, ANY_MERGE, askpassInit, askpassSubmitPromptResponse, CHILD, HORIZ_ANCESTOR, HORIZ_PARENT, HORIZONTAL, LEFT_FORK, LEFT_FORK_ANCESTOR, LEFT_FORK_PARENT, LEFT_MERGE, LEFT_MERGE_ANCESTOR, LEFT_MERGE_PARENT, RIGHT_FORK, RIGHT_FORK_ANCESTOR, RIGHT_FORK_PARENT, RIGHT_MERGE, RIGHT_MERGE_ANCESTOR, RIGHT_MERGE_PARENT, VERT_ANCESTOR, VERT_PARENT, VERTICAL, watcherStart } = nativeBinding
+const { absorb, absorptionPlan, apply, applyBranchIntegration, assignHunk, branchCheckout, branchCheckoutNew, branchCreate, branchDetails, branchDiff, branchLand, branchRemove, changesInWorktree, changesInWorktreeWithPerm, commitAmend, commitCreate, commitDetailsWithLineStats, commitDiscard, commitDiscardChanges, commitInsertBlank, commitMove, commitMoveChangesBetween, commitReword, commitSquash, commitUncommit, commitUncommitChanges, commitUncommitChangesFromCommits, discardWorktreeChanges, forgeCompareBranchUrl, forgeInfo, forgeProvider, getInitialBranchIntegration, getRedoTargetSnapshot, getRepoInfo, getReview, getReviewBaseRepoUrl, getReviewMergeStatus, getUndoTargetSnapshot, getWorkspace, headInfo, initApplicationNamespace, listAvailableReviewTemplates, listBranches, listCiChecks, listEditors, listProjectsStateless, listReviews, listReviewsForBranch, mergeReview, moveBranch, openInEditor, peelRestoreSnapshot, publishReview, pushStack, removeBranch, restoreSnapshotWithKind, reviewApply, reviewTemplate, setReviewAutoMerge, setReviewDraftiness, setReviewTemplate, setTargetRefAndInitProject, tearOffBranch, treeChangeDiffs, unapplyStack, updateBranchName, updateReview, updateReviewFooters, warmCiChecksCache, workspaceBranchAndAncestorsPush, workspaceCheckout, workspaceIntegrateUpstream, WatcherHandle, ANY_FORK, ANY_FORK_OR_MERGE, ANY_MERGE, askpassInit, askpassSubmitPromptResponse, CHILD, HORIZ_ANCESTOR, HORIZ_PARENT, HORIZONTAL, LEFT_FORK, LEFT_FORK_ANCESTOR, LEFT_FORK_PARENT, LEFT_MERGE, LEFT_MERGE_ANCESTOR, LEFT_MERGE_PARENT, RIGHT_FORK, RIGHT_FORK_ANCESTOR, RIGHT_FORK_PARENT, RIGHT_MERGE, RIGHT_MERGE_ANCESTOR, RIGHT_MERGE_PARENT, VERT_ANCESTOR, VERT_PARENT, VERTICAL, watcherStart } = nativeBinding
 export { absorb }
 export { absorptionPlan }
 export { apply }
@@ -641,6 +641,7 @@ export { reviewTemplate }
 export { setReviewAutoMerge }
 export { setReviewDraftiness }
 export { setReviewTemplate }
+export { setTargetRefAndInitProject }
 export { tearOffBranch }
 export { treeChangeDiffs }
 export { unapplyStack }
diff --git a/packages/but-sdk/src/generated/linear/index.d.ts b/packages/but-sdk/src/generated/linear/index.d.ts
index 298fce7c07b..08c496195fa 100644
--- a/packages/but-sdk/src/generated/linear/index.d.ts
+++ b/packages/but-sdk/src/generated/linear/index.d.ts
@@ -473,6 +473,18 @@ export declare function setReviewDraftiness(projectId: string, reviewId: number,
  */
 export declare function setReviewTemplate(projectId: string, templatePath: string | null): Promise<void>
 
+/**
+ * Make `target_ref` the project's default target without applying branches or entering
+ * managed workspace mode.
+ *
+ * This acquires exclusive worktree access from `ctx` before updating project metadata.
+ * See [`but_workspace::init::set_target_ref_and_init_project()`] for details; notably the
+ * target commit id is only computed when it wasn't set before, and an omitted
+ * `push_remote` keeps the currently configured one. It deliberately records no oplog
+ * snapshot - only project metadata changes, no repository state.
+ */
+export declare function setTargetRefAndInitProject(projectId: string, targetRef: string, pushRemote: string | null): Promise<void>
+
 /**
  * Tears off a branch using the behavior described by [`tear_off_branch_with_perm()`].
  *
diff --git a/packages/but-sdk/src/generated/linear/index.js b/packages/but-sdk/src/generated/linear/index.js
index 20fb755379d..ac17f9c7e21 100644
--- a/packages/but-sdk/src/generated/linear/index.js
+++ b/packages/but-sdk/src/generated/linear/index.js
@@ -579,7 +579,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { absorb, absorptionPlan, apply, applyBranchIntegration, assignHunk, branchCheckout, branchCheckoutNew, branchCreate, branchDetails, branchDiff, branchLand, branchRemove, changesInWorktree, changesInWorktreeWithPerm, commitAmend, commitCreate, commitDetailsWithLineStats, commitDiscard, commitDiscardChanges, commitInsertBlank, commitMove, commitMoveChangesBetween, commitReword, commitSquash, commitUncommit, commitUncommitChanges, commitUncommitChangesFromCommits, discardWorktreeChanges, forgeCompareBranchUrl, forgeInfo, forgeProvider, getInitialBranchIntegration, getRedoTargetSnapshot, getRepoInfo, getReview, getReviewBaseRepoUrl, getReviewMergeStatus, getUndoTargetSnapshot, getWorkspace, headInfo, initApplicationNamespace, listAvailableReviewTemplates, listBranches, listCiChecks, listEditors, listProjectsStateless, listReviews, listReviewsForBranch, mergeReview, moveBranch, openInEditor, peelRestoreSnapshot, publishReview, pushStack, removeBranch, restoreSnapshotWithKind, reviewApply, reviewTemplate, setReviewAutoMerge, setReviewDraftiness, setReviewTemplate, tearOffBranch, treeChangeDiffs, unapplyStack, updateBranchName, updateReview, updateReviewFooters, warmCiChecksCache, workspaceBranchAndAncestorsPush, workspaceCheckout, workspaceIntegrateUpstream, WatcherHandle, ANY_FORK, ANY_FORK_OR_MERGE, ANY_MERGE, askpassInit, askpassSubmitPromptResponse, CHILD, HORIZ_ANCESTOR, HORIZ_PARENT, HORIZONTAL, LEFT_FORK, LEFT_FORK_ANCESTOR, LEFT_FORK_PARENT, LEFT_MERGE, LEFT_MERGE_ANCESTOR, LEFT_MERGE_PARENT, RIGHT_FORK, RIGHT_FORK_ANCESTOR, RIGHT_FORK_PARENT, RIGHT_MERGE, RIGHT_MERGE_ANCESTOR, RIGHT_MERGE_PARENT, VERT_ANCESTOR, VERT_PARENT, VERTICAL, watcherStart } = nativeBinding
+const { absorb, absorptionPlan, apply, applyBranchIntegration, assignHunk, branchCheckout, branchCheckoutNew, branchCreate, branchDetails, branchDiff, branchLand, branchRemove, changesInWorktree, changesInWorktreeWithPerm, commitAmend, commitCreate, commitDetailsWithLineStats, commitDiscard, commitDiscardChanges, commitInsertBlank, commitMove, commitMoveChangesBetween, commitReword, commitSquash, commitUncommit, commitUncommitChanges, commitUncommitChangesFromCommits, discardWorktreeChanges, forgeCompareBranchUrl, forgeInfo, forgeProvider, getInitialBranchIntegration, getRedoTargetSnapshot, getRepoInfo, getReview, getReviewBaseRepoUrl, getReviewMergeStatus, getUndoTargetSnapshot, getWorkspace, headInfo, initApplicationNamespace, listAvailableReviewTemplates, listBranches, listCiChecks, listEditors, listProjectsStateless, listReviews, listReviewsForBranch, mergeReview, moveBranch, openInEditor, peelRestoreSnapshot, publishReview, pushStack, removeBranch, restoreSnapshotWithKind, reviewApply, reviewTemplate, setReviewAutoMerge, setReviewDraftiness, setReviewTemplate, setTargetRefAndInitProject, tearOffBranch, treeChangeDiffs, unapplyStack, updateBranchName, updateReview, updateReviewFooters, warmCiChecksCache, workspaceBranchAndAncestorsPush, workspaceCheckout, workspaceIntegrateUpstream, WatcherHandle, ANY_FORK, ANY_FORK_OR_MERGE, ANY_MERGE, askpassInit, askpassSubmitPromptResponse, CHILD, HORIZ_ANCESTOR, HORIZ_PARENT, HORIZONTAL, LEFT_FORK, LEFT_FORK_ANCESTOR, LEFT_FORK_PARENT, LEFT_MERGE, LEFT_MERGE_ANCESTOR, LEFT_MERGE_PARENT, RIGHT_FORK, RIGHT_FORK_ANCESTOR, RIGHT_FORK_PARENT, RIGHT_MERGE, RIGHT_MERGE_ANCESTOR, RIGHT_MERGE_PARENT, VERT_ANCESTOR, VERT_PARENT, VERTICAL, watcherStart } = nativeBinding
 export { absorb }
 export { absorptionPlan }
 export { apply }
@@ -641,6 +641,7 @@ export { reviewTemplate }
 export { setReviewAutoMerge }
 export { setReviewDraftiness }
 export { setReviewTemplate }
+export { setTargetRefAndInitProject }
 export { tearOffBranch }
 export { treeChangeDiffs }
 export { unapplyStack }