diff --git a/.gitignore b/.gitignore
index 70bf5db..a2e2c41 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,9 @@ web/dist/*
 web/coverage/
 web/*.tsbuildinfo
 docs/production-checklist.md
+
+# Gas Town (added by gt)
+.runtime/
+.claude/
+.logs/
+__pycache__/
diff --git a/cmd/wl/cmd_config.go b/cmd/wl/cmd_config.go
index 375ddaf..b01fcfc 100644
--- a/cmd/wl/cmd_config.go
+++ b/cmd/wl/cmd_config.go
@@ -139,6 +139,11 @@ func runConfigSet(cmd *cobra.Command, stdout, _ io.Writer, key, value string) er
 		return hintWrap(err)
 	}
 
+	// Validate mode-backend compatibility at config time.
+	if key == "mode" && value == federation.ModeWildWest && cfg.ResolveBackend() == federation.BackendRemote {
+		return fmt.Errorf("wild-west mode requires local backend; switch to local first: wl config set backend local")
+	}
+
 	switch key {
 	case "mode":
 		cfg.Mode = value
diff --git a/cmd/wl/cmd_join.go b/cmd/wl/cmd_join.go
index 47e9970..3204d92 100644
--- a/cmd/wl/cmd_join.go
+++ b/cmd/wl/cmd_join.go
@@ -275,7 +275,7 @@ func runJoinRemote(stdout, _ io.Writer, upstream, handle, displayName, email, fo
 
 	// 2. Register rig via RemoteDB.Exec on a registration branch.
 	fmt.Fprintf(stdout, "  Registering rig via API...\n")
-	db := backend.NewRemoteDB(token, upstreamOrg, upstreamDB, forkOrg, upstreamDB, federation.ModePR)
+	db := backend.NewRemoteDB(token, upstreamOrg, upstreamDB, forkOrg, upstreamDB)
 	branch := fmt.Sprintf("wl/register/%s", handle)
 	regSQL := commons.BuildRegistrationSQL(handle, forkOrg, displayName, email, "dev")
 	if err := db.Exec(branch, "", false, regSQL); err != nil {
diff --git a/cmd/wl/cmd_merge.go b/cmd/wl/cmd_merge.go
index eef157a..4eb779f 100644
--- a/cmd/wl/cmd_merge.go
+++ b/cmd/wl/cmd_merge.go
@@ -94,7 +94,7 @@ func runMerge(cmd *cobra.Command, stdout, _ io.Writer, branch string, noPush, ke
 	}
 
 	if !noPush {
-		if err := commons.PushWithSync(cfg.LocalDir, stdout); err != nil {
+		if err := commons.PushAllRemotes(cfg.LocalDir, stdout); err != nil {
 			fmt.Fprintf(stdout, "\n  %s %s\n", style.Warning.Render(style.IconWarn),
 				"Push failed — merge saved locally. Run 'wl sync' to retry.")
 		}
diff --git a/cmd/wl/cmd_serve.go b/cmd/wl/cmd_serve.go
index 646c509..2bde8d0 100644
--- a/cmd/wl/cmd_serve.go
+++ b/cmd/wl/cmd_serve.go
@@ -120,7 +120,7 @@ func runServe(cmd *cobra.Command, stdout, stderr io.Writer) error {
 		if err := requireDolt(); err != nil {
 			return err
 		}
-		localDB := backend.NewLocalDB(cfg.LocalDir, cfg.ResolveMode())
+		localDB := backend.NewLocalDB(cfg.LocalDir, syncFnForMode(cfg.ResolveMode()))
 		db = localDB
 
 		sp := style.StartSpinner(stderr, "Syncing with upstream...")
@@ -144,7 +144,7 @@ func runServe(cmd *cobra.Command, stdout, stderr io.Writer) error {
 		if err != nil {
 			return fmt.Errorf("parsing upstream: %w", err)
 		}
-		remoteDB := backend.NewRemoteDB(token, upOrg, upDB, cfg.ForkOrg, cfg.ForkDB, cfg.ResolveMode())
+		remoteDB := backend.NewRemoteDB(token, upOrg, upDB, cfg.ForkOrg, cfg.ForkDB)
 		db = remoteDB
 
 		sp := style.StartSpinner(stderr, "Syncing fork with upstream...")
@@ -286,7 +286,7 @@ func runServeHosted(cmd *cobra.Command, stdout, _ io.Writer) error {
 	apiServer := api.NewHostedWorkspace(hosted.NewClientFunc(), hosted.NewWorkspaceFunc())
 
 	// Public read-only RemoteDB against hop/wl-commons (no token needed).
-	publicDB := backend.NewRemoteDB("", "hop", "wl-commons", "hop", "wl-commons", "")
+	publicDB := backend.NewRemoteDB("", "hop", "wl-commons", "hop", "wl-commons")
 
 	// Scoreboard cache.
 	scoreboardCache := api.NewScoreboardCache(publicDB, 5*time.Minute)
diff --git a/cmd/wl/cmd_tui.go b/cmd/wl/cmd_tui.go
index bf025bd..701fb2a 100644
--- a/cmd/wl/cmd_tui.go
+++ b/cmd/wl/cmd_tui.go
@@ -39,7 +39,7 @@ func runTUI(cmd *cobra.Command, _, stderr io.Writer) error {
 		if err := requireDolt(); err != nil {
 			return err
 		}
-		localDB := backend.NewLocalDB(cfg.LocalDir, cfg.ResolveMode())
+		localDB := backend.NewLocalDB(cfg.LocalDir, syncFnForMode(cfg.ResolveMode()))
 		db = localDB
 
 		// Sync before launching the TUI.
@@ -61,7 +61,7 @@ func runTUI(cmd *cobra.Command, _, stderr io.Writer) error {
 		if err != nil {
 			return fmt.Errorf("parsing upstream: %w", err)
 		}
-		remoteDB := backend.NewRemoteDB(commons.DoltHubToken(), upOrg, upDB, cfg.ForkOrg, cfg.ForkDB, cfg.ResolveMode())
+		remoteDB := backend.NewRemoteDB(commons.DoltHubToken(), upOrg, upDB, cfg.ForkOrg, cfg.ForkDB)
 		db = remoteDB
 
 		sp := style.StartSpinner(stderr, "Syncing fork with upstream...")
diff --git a/cmd/wl/store_factory.go b/cmd/wl/store_factory.go
index c53061e..2845c15 100644
--- a/cmd/wl/store_factory.go
+++ b/cmd/wl/store_factory.go
@@ -11,14 +11,22 @@ import (
 // openDB creates a commons.DB for the given local database directory.
 // Package-level variable to allow test overrides.
 var openDB = func(localDir string) commons.DB {
-	return backend.NewLocalDB(localDir, "")
+	return backend.NewLocalDB(localDir, nil)
+}
+
+// syncFnForMode returns the appropriate sync function for the given mode.
+func syncFnForMode(mode string) func(string) error {
+	if mode == federation.ModePR {
+		return backend.PRSync
+	}
+	return backend.WildWestSync
 }
 
 // openDBFromConfig creates a commons.DB using the resolved backend from config.
 // Package-level variable to allow test overrides.
 var openDBFromConfig = func(cfg *federation.Config) (commons.DB, error) {
 	if cfg.ResolveBackend() == federation.BackendLocal {
-		return backend.NewLocalDB(cfg.LocalDir, cfg.ResolveMode()), nil
+		return backend.NewLocalDB(cfg.LocalDir, syncFnForMode(cfg.ResolveMode())), nil
 	}
 	if cfg.IsGitHub() {
 		return nil, fmt.Errorf("GitHub backend requires local dolt\n\n  Install: https://docs.dolthub.com/introduction/installation\n  Then: wl join --github %s --local-db", cfg.Upstream)
@@ -31,5 +39,5 @@ var openDBFromConfig = func(cfg *federation.Config) (commons.DB, error) {
 	if err != nil {
 		return nil, err
 	}
-	return backend.NewRemoteDB(token, upOrg, upDB, cfg.ForkOrg, cfg.ForkDB, cfg.ResolveMode()), nil
+	return backend.NewRemoteDB(token, upOrg, upDB, cfg.ForkOrg, cfg.ForkDB), nil
 }
diff --git a/cmd/wl/store_factory_test.go b/cmd/wl/store_factory_test.go
index d6fa7c0..a64e93b 100644
--- a/cmd/wl/store_factory_test.go
+++ b/cmd/wl/store_factory_test.go
@@ -25,7 +25,7 @@ func (noopDB) PushMain(io.Writer) error                   { return nil }
 func (noopDB) Sync() error                                { return nil }
 func (noopDB) MergeBranch(string) error                   { return nil }
 func (noopDB) DeleteRemoteBranch(string) error            { return nil }
-func (noopDB) PushWithSync(io.Writer) error               { return nil }
+func (noopDB) PushAllRemotes(io.Writer) error             { return nil }
 func (noopDB) CanWildWest() error                         { return nil }
 
 // withFakeSDK overrides newSDKClient and resolveWantedArg for test isolation.
diff --git a/internal/api/server_test.go b/internal/api/server_test.go
index a4ba451..4b4196e 100644
--- a/internal/api/server_test.go
+++ b/internal/api/server_test.go
@@ -219,7 +219,7 @@ func (f *fakeDB) PushMain(_ io.Writer) error             { return nil }
 func (f *fakeDB) Sync() error                            { return nil }
 func (f *fakeDB) MergeBranch(_ string) error             { return nil }
 func (f *fakeDB) DeleteRemoteBranch(_ string) error      { return nil }
-func (f *fakeDB) PushWithSync(_ io.Writer) error         { return nil }
+func (f *fakeDB) PushAllRemotes(_ io.Writer) error       { return nil }
 func (f *fakeDB) CanWildWest() error                     { return nil }
 
 func (f *fakeDB) resolve(id, ref string) *fakeItem {
diff --git a/internal/backend/backend.go b/internal/backend/backend.go
index b5ccabb..c1fb677 100644
--- a/internal/backend/backend.go
+++ b/internal/backend/backend.go
@@ -40,8 +40,8 @@ type DB interface {
 	// DeleteRemoteBranch removes a branch on the origin remote. No-op for remote.
 	DeleteRemoteBranch(branch string) error
 
-	// PushWithSync pushes to both upstream and origin with sync retry. No-op for remote.
-	PushWithSync(stdout io.Writer) error
+	// PushAllRemotes pushes to both upstream and origin with sync retry. No-op for remote.
+	PushAllRemotes(stdout io.Writer) error
 
 	// CanWildWest returns nil if the backend supports wild-west mode (direct
 	// upstream writes). Returns an error with a user-facing message if not.
diff --git a/internal/backend/local.go b/internal/backend/local.go
index 869e292..7fa91eb 100644
--- a/internal/backend/local.go
+++ b/internal/backend/local.go
@@ -11,14 +11,18 @@ import (
 
 // LocalDB implements DB using the local dolt CLI.
 type LocalDB struct {
-	dir  string
-	mode string // "pr" or "wild-west"
+	dir    string
+	syncFn func(dir string) error // injected sync strategy
 }
 
 // NewLocalDB creates a DB backed by a local dolt database directory.
-// mode determines Sync behavior: "pr" resets to upstream, otherwise pulls.
-func NewLocalDB(dir, mode string) *LocalDB {
-	return &LocalDB{dir: dir, mode: mode}
+// syncFn determines Sync behavior; use PRSync or WildWestSync.
+// If syncFn is nil, defaults to WildWestSync.
+func NewLocalDB(dir string, syncFn func(string) error) *LocalDB {
+	if syncFn == nil {
+		syncFn = WildWestSync
+	}
+	return &LocalDB{dir: dir, syncFn: syncFn}
 }
 
 // Dir returns the local database directory path.
@@ -88,26 +92,33 @@ func (l *LocalDB) PushMain(stdout io.Writer) error {
 	return commons.PushOriginMain(l.dir, stdout)
 }
 
-// PushWithSync pushes to both upstream and origin with sync retry.
-func (l *LocalDB) PushWithSync(stdout io.Writer) error {
-	return commons.PushWithSync(l.dir, stdout)
+// PushAllRemotes pushes to both upstream and origin with sync retry.
+func (l *LocalDB) PushAllRemotes(stdout io.Writer) error {
+	return commons.PushAllRemotes(l.dir, stdout)
 }
 
 // CanWildWest returns nil — local databases support wild-west mode.
 func (l *LocalDB) CanWildWest() error { return nil }
 
-// Sync pulls latest from upstream. In PR mode, resets main to upstream
-// and fetches origin branches so PR mutations are visible via AS OF.
+// Sync pulls latest from upstream using the injected sync strategy.
 func (l *LocalDB) Sync() error {
-	if l.mode == "pr" {
-		if err := commons.ResetMainToUpstream(l.dir); err != nil {
-			return err
-		}
-		_ = commons.FetchRemote(l.dir, "origin")
-		_ = commons.TrackOriginBranches(l.dir, "wl/")
-		return nil
+	return l.syncFn(l.dir)
+}
+
+// PRSync resets main to upstream and fetches origin branches so PR
+// mutations are visible via AS OF.
+func PRSync(dir string) error {
+	if err := commons.ResetMainToUpstream(dir); err != nil {
+		return err
 	}
-	return commons.PullUpstream(l.dir)
+	_ = commons.FetchRemote(dir, "origin")
+	_ = commons.TrackOriginBranches(dir, "wl/")
+	return nil
+}
+
+// WildWestSync pulls latest changes from the upstream remote.
+func WildWestSync(dir string) error {
+	return commons.PullUpstream(dir)
 }
 
 // MergeBranch merges a branch into main.
diff --git a/internal/backend/remote.go b/internal/backend/remote.go
index eea1ae9..58f4f9c 100644
--- a/internal/backend/remote.go
+++ b/internal/backend/remote.go
@@ -27,19 +27,17 @@ type RemoteDB struct {
 	readDB     string // upstream db name
 	writeOwner string // fork org
 	writeDB    string // fork db name
-	mode       string // "pr" or "wild-west"
 	client     *http.Client
 }
 
 // NewRemoteDB creates a DB backed by the DoltHub REST API.
-func NewRemoteDB(token, readOwner, readDB, writeOwner, writeDB, mode string) *RemoteDB {
+func NewRemoteDB(token, readOwner, readDB, writeOwner, writeDB string) *RemoteDB {
 	return &RemoteDB{
 		token:      token,
 		readOwner:  readOwner,
 		readDB:     readDB,
 		writeOwner: writeOwner,
 		writeDB:    writeDB,
-		mode:       mode,
 		client:     &http.Client{Timeout: 60 * time.Second},
 	}
 }
@@ -47,13 +45,12 @@ func NewRemoteDB(token, readOwner, readDB, writeOwner, writeDB, mode string) *Re
 // NewRemoteDBWithClient creates a DB backed by the DoltHub REST API using a
 // pre-configured HTTP client. The client's transport is responsible for auth
 // (e.g. Nango proxy), so no token is stored.
-func NewRemoteDBWithClient(client *http.Client, readOwner, readDB, writeOwner, writeDB, mode string) *RemoteDB {
+func NewRemoteDBWithClient(client *http.Client, readOwner, readDB, writeOwner, writeDB string) *RemoteDB {
 	return &RemoteDB{
 		readOwner:  readOwner,
 		readDB:     readDB,
 		writeOwner: writeOwner,
 		writeDB:    writeDB,
-		mode:       mode,
 		client:     client,
 	}
 }
@@ -191,8 +188,8 @@ func (r *RemoteDB) PushBranch(_ string, _ io.Writer) error { return nil }
 // PushMain is a no-op for remote.
 func (r *RemoteDB) PushMain(_ io.Writer) error { return nil }
 
-// PushWithSync is a no-op for remote — the write API auto-pushes.
-func (r *RemoteDB) PushWithSync(_ io.Writer) error { return nil }
+// PushAllRemotes is a no-op for remote — the write API auto-pushes.
+func (r *RemoteDB) PushAllRemotes(_ io.Writer) error { return nil }
 
 // CanWildWest returns an error — the DoltHub REST API cannot push from a fork
 // to the upstream, so wild-west mode is not supported.
diff --git a/internal/backend/remote_test.go b/internal/backend/remote_test.go
index 3e6d8d1..81ed95a 100644
--- a/internal/backend/remote_test.go
+++ b/internal/backend/remote_test.go
@@ -43,7 +43,7 @@ func TestRemoteDB_Query_Main(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	csv, err := db.Query("SELECT id, status FROM wanted", "")
@@ -79,7 +79,7 @@ func TestRemoteDB_Query_Branch(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	csv, err := db.Query("SELECT status FROM wanted WHERE id='w-001'", "wl/alice/w-001")
@@ -123,7 +123,7 @@ func TestRemoteDB_Exec(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.Exec("wl/alice/w-001", "wl claim: w-001", false,
@@ -164,7 +164,7 @@ func TestRemoteDB_Exec_SequentialMutation(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.Exec("wl/alice/w-001", "wl done: w-001", false,
@@ -187,7 +187,7 @@ func TestRemoteDB_Exec_MainBranch(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.Exec("", "wl claim: w-001", false,
@@ -213,7 +213,7 @@ func TestRemoteDB_Branches(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	branches, err := db.Branches("wl/alice/")
@@ -230,7 +230,7 @@ func TestRemoteDB_Branches(t *testing.T) {
 
 func TestRemoteDB_PushNoOps(t *testing.T) {
 	t.Parallel()
-	db := NewRemoteDB("token", "up", "db", "fork", "db", "pr")
+	db := NewRemoteDB("token", "up", "db", "fork", "db")
 
 	if err := db.PushBranch("branch", nil); err != nil {
 		t.Errorf("PushBranch should be no-op, got: %v", err)
@@ -238,8 +238,8 @@ func TestRemoteDB_PushNoOps(t *testing.T) {
 	if err := db.PushMain(nil); err != nil {
 		t.Errorf("PushMain should be no-op, got: %v", err)
 	}
-	if err := db.PushWithSync(nil); err != nil {
-		t.Errorf("PushWithSync should be no-op, got: %v", err)
+	if err := db.PushAllRemotes(nil); err != nil {
+		t.Errorf("PushAllRemotes should be no-op, got: %v", err)
 	}
 	if err := db.CanWildWest(); err == nil {
 		t.Error("CanWildWest should return error for remote DB")
@@ -287,7 +287,7 @@ func TestRemoteDB_Exec_Poll(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.Exec("some-branch", "test", false, "UPDATE wanted SET status='open'")
@@ -342,7 +342,7 @@ func TestRemoteDB_Exec_Poll_DoneResDetails(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.Exec("some-branch", "test", false, "INSERT INTO wanted VALUES (...)")
@@ -361,7 +361,7 @@ func TestRemoteDB_Query_Error(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	_, err := db.Query("SELECT 1", "")
@@ -375,7 +375,7 @@ func TestRemoteDB_Sync_NoOp(t *testing.T) {
 	// remote operations (dolt_remotes, DOLT_FETCH). Reads go directly to the
 	// upstream API so fork-level sync is unnecessary.
 	t.Parallel()
-	db := NewRemoteDB("token", "up", "db", "fork", "db", "pr")
+	db := NewRemoteDB("token", "up", "db", "fork", "db")
 	if err := db.Sync(); err != nil {
 		t.Errorf("Sync should be no-op, got: %v", err)
 	}
@@ -398,7 +398,7 @@ func TestRemoteDB_MergeBranch(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	if err := db.MergeBranch("wl/alice/w-001"); err != nil {
@@ -426,7 +426,7 @@ func TestRemoteDB_DeleteBranch(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	if err := db.DeleteBranch("wl/alice/w-001"); err != nil {
@@ -456,7 +456,7 @@ func TestRemoteDB_DeleteBranch_ReturnsError(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	err := db.DeleteBranch("wl/alice/w-001")
@@ -470,7 +470,7 @@ func TestRemoteDB_DeleteBranch_ReturnsError(t *testing.T) {
 
 func TestRemoteDB_DeleteBranch_MainNoOp(t *testing.T) {
 	// Deleting main or empty branch should be a no-op.
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	if err := db.DeleteBranch("main"); err != nil {
 		t.Fatalf("DeleteBranch(main) error: %v", err)
 	}
@@ -535,7 +535,7 @@ func TestRemoteDB_Diff(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	diff, err := db.Diff("wl/alice/w-001")
@@ -613,7 +613,7 @@ func TestRemoteDB_Diff_FieldsWithCommas(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	diff, err := db.Diff("wl/alice/w-001")
@@ -648,7 +648,7 @@ func TestRemoteDB_Diff_NoChanges(t *testing.T) {
 	})
 	defer cleanup()
 
-	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons", "pr")
+	db := NewRemoteDB("test-token", "upstream-org", "wl-commons", "fork-org", "wl-commons")
 	db.client = srv.Client()
 
 	diff, err := db.Diff("wl/alice/w-001")
diff --git a/internal/commons/commons.go b/internal/commons/commons.go
index f0baf01..5021ba2 100644
--- a/internal/commons/commons.go
+++ b/internal/commons/commons.go
@@ -48,8 +48,8 @@ type DB interface {
 	// DeleteRemoteBranch removes a branch on the origin remote.
 	DeleteRemoteBranch(branch string) error
 
-	// PushWithSync pushes to both upstream and origin with sync retry.
-	PushWithSync(stdout io.Writer) error
+	// PushAllRemotes pushes to both upstream and origin with sync retry.
+	PushAllRemotes(stdout io.Writer) error
 
 	// CanWildWest returns nil if the backend supports wild-west mode.
 	CanWildWest() error
diff --git a/internal/commons/dolt.go b/internal/commons/dolt.go
index 426ae81..deac5b1 100644
--- a/internal/commons/dolt.go
+++ b/internal/commons/dolt.go
@@ -34,10 +34,10 @@ func DoltHubOrg() string {
 	return os.Getenv("DOLTHUB_ORG")
 }
 
-// PushWithSync pushes the local main branch to both upstream and origin remotes.
+// PushAllRemotes pushes the local main branch to both upstream and origin remotes.
 // If a push is rejected (stale), it pulls to merge and retries.
 // Returns an error if any remote push ultimately fails.
-func PushWithSync(dbDir string, stdout io.Writer) error {
+func PushAllRemotes(dbDir string, stdout io.Writer) error {
 	var failures []string
 	for _, remote := range []string{"upstream", "origin"} {
 		if err := pushRemote(dbDir, remote); err != nil {
diff --git a/internal/commons/leaderboard_test.go b/internal/commons/leaderboard_test.go
index e478ede..b837e99 100644
--- a/internal/commons/leaderboard_test.go
+++ b/internal/commons/leaderboard_test.go
@@ -35,7 +35,7 @@ func (f *fakeDB) PushMain(_ io.Writer) error                  { return nil }
 func (f *fakeDB) Sync() error                                 { return nil }
 func (f *fakeDB) MergeBranch(_ string) error                  { return nil }
 func (f *fakeDB) DeleteRemoteBranch(_ string) error           { return nil }
-func (f *fakeDB) PushWithSync(_ io.Writer) error              { return nil }
+func (f *fakeDB) PushAllRemotes(_ io.Writer) error            { return nil }
 func (f *fakeDB) CanWildWest() error                          { return nil }
 
 func TestQueryLeaderboard_BasicRanking(t *testing.T) {
diff --git a/internal/hosted/fork_register.go b/internal/hosted/fork_register.go
index bc146a0..7508227 100644
--- a/internal/hosted/fork_register.go
+++ b/internal/hosted/fork_register.go
@@ -42,7 +42,7 @@ func (d *DoltHubForkRegistrar) EnsureForkAndRegister(apiKey, upstream, forkOrg,
 
 	// 2. Register rig on a branch via the DoltHub SQL API.
 	// Write DB must be upstreamDB (fork preserves the original DB name on DoltHub).
-	db := backend.NewRemoteDB(apiKey, upstreamOrg, upstreamDB, forkOrg, upstreamDB, federation.ModePR)
+	db := backend.NewRemoteDB(apiKey, upstreamOrg, upstreamDB, forkOrg, upstreamDB)
 	branch := fmt.Sprintf("wl/register/%s", rigHandle)
 	regSQL := commons.BuildRegistrationSQL(rigHandle, forkOrg, displayName, email, "hosted")
 	// Retry with backoff — newly created forks may not be immediately available
diff --git a/internal/hosted/resolver.go b/internal/hosted/resolver.go
index 75ec69c..24a1a41 100644
--- a/internal/hosted/resolver.go
+++ b/internal/hosted/resolver.go
@@ -187,7 +187,7 @@ func (wr *WorkspaceResolver) buildClient(wl *WastelandConfig, rigHandle, connect
 		mode = "pr"
 	}
 
-	db := backend.NewRemoteDB(apiKey, upOrg, upDB, wl.ForkOrg, wl.ForkDB, mode)
+	db := backend.NewRemoteDB(apiKey, upOrg, upDB, wl.ForkOrg, wl.ForkDB)
 
 	provider := remote.NewDoltHubProvider(apiKey)
 
diff --git a/internal/sdk/conformance_test.go b/internal/sdk/conformance_test.go
index 371d2ee..a0da545 100644
--- a/internal/sdk/conformance_test.go
+++ b/internal/sdk/conformance_test.go
@@ -81,7 +81,7 @@ func setupLocalDB(t *testing.T) commons.DB {
 		t.Fatalf("init schema: %v", err)
 	}
 
-	return backend.NewLocalDB(dir, "wild-west")
+	return backend.NewLocalDB(dir, backend.WildWestSync)
 }
 
 // --- seeding helpers ---
diff --git a/internal/sdk/mutate.go b/internal/sdk/mutate.go
index 3fea823..a4a1d06 100644
--- a/internal/sdk/mutate.go
+++ b/internal/sdk/mutate.go
@@ -43,7 +43,7 @@ func (c *Client) mutateWildWest(wantedID, commitMsg string, stmts ...string) (*M
 		return nil, err
 	}
 	if !c.noPush {
-		if err := c.db.PushWithSync(io.Discard); err != nil {
+		if err := c.db.PushAllRemotes(io.Discard); err != nil {
 			return nil, err
 		}
 	}
diff --git a/internal/sdk/sdk_test.go b/internal/sdk/sdk_test.go
index 2bae7aa..49fc7da 100644
--- a/internal/sdk/sdk_test.go
+++ b/internal/sdk/sdk_test.go
@@ -535,7 +535,7 @@ func (f *fakeDB) MergeBranch(branch string) error {
 
 func (f *fakeDB) DeleteRemoteBranch(_ string) error { return nil }
 
-func (f *fakeDB) PushWithSync(_ io.Writer) error {
+func (f *fakeDB) PushAllRemotes(_ io.Writer) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.pushCalls++