@narumitw/pi-sync 0.31.0 → 0.35.0

package/src/manager-ui.ts

@@ -1,120 +1,117 @@
 import { BorderedLoader, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { setSyncTargetCompletions } from "./command.js";
+import { setSyncSetupCompletions } from "./command.js";
 import {
 	activeLocalConfigPath,
-	configuredTargetNames,
-	deprecatedPiSyncEnvironmentWarnings,
+	configuredSyncSetupNames,
 	isCloudflareR2Endpoint,
 	loadConfig,
+	loadOnSwitch,
 	loadPartialConfig,
-	loadTargetSwitchAction,
 	localConfigPath,
-	normalizeSyncFiles,
 	readLocalConfigObject,
 	readStateForConfig,
+	syncConfigReviewIdentity,
 } from "./config.js";
+import { showAddGitTarget, showEditGitTarget, showGitSetup } from "./git-ui.js";
 import { inspectLock, isStaleLock } from "./lock.js";
 import {
-	addStorageProfile,
-	addSyncTarget,
-	migrateLegacySettings,
-	removeStorageProfile,
-	removeSyncTarget,
-	saveNewV2Settings,
-	updateStorageProfile,
-	updateSyncTarget,
+	errorMessage,
+	ownRecord,
+	requiredExistingBucket,
+	requiredInput,
+	safeTerminalText,
+} from "./manager-helpers.js";
+import { chooseS3Credentials } from "./s3-credentials-ui.js";
+import {
+	addSyncSetup,
+	removeSyncSetup,
+	saveNewV3Settings,
+	updateSyncSetup,
 } from "./settings-management.js";
 import { showSyncSettings } from "./settings-ui.js";
-import { DEFAULT_SYNC_FILES } from "./sync-policy.js";
-import { type TargetPullOutcome, useSyncTarget } from "./target-switch.js";
-import type { SyncConfig } from "./types.js";
+import { type SetupPullOutcome, useSyncSetup } from "./setup-switch.js";
+import { showAddStorageConnection, showStorageConnections } from "./storage-connections-ui.js";
+import { DEFAULT_SYNC_INCLUDE, syncIncludeSelection } from "./sync-policy.js";
+import { countValidSyncSetups, showSyncSetups } from "./sync-setups-ui.js";
+import type { AnySyncConfig } from "./types.js";
+import { showAddWebDavTarget, showEditWebDavTarget, showWebDavSetup } from "./webdav-ui.js";
 
 export const MAIN_MENU_ACTIONS = [
 	"Sync now (recommended)",
-	"Pull from remote",
-	"Push to remote",
-	"Switch target",
+	"Switch sync setup",
 	"Status & changes",
 	"Settings",
 	"More…",
 ] as const;
-
 const MORE_MENU_ACTIONS = [
-	"Manage targets & storage",
-	"History & recovery",
+	"Pull from remote…",
+	"Push to remote…",
+	"Sync setups…",
+	"Storage connections…",
+	"History & recovery…",
 	"Help",
 	"Back",
 ] as const;
 const BACK = "Back";
 
 type MainMenuAction = (typeof MAIN_MENU_ACTIONS)[number];
-type ContextualMenuAction = "Manage targets & storage" | "History & recovery" | "Help";
 type RunRoute = (
 	route: string,
 	signal?: AbortSignal,
 	onCommit?: () => void,
 	target?: string,
-) => Promise<TargetPullOutcome | undefined>;
+) => Promise<SetupPullOutcome | undefined>;
 
 export async function showSyncManager(
 	ctx: ExtensionCommandContext,
 	runRoute: RunRoute,
+	sessionSignal?: AbortSignal,
 ): Promise<void> {
 	if (!ctx.hasUI) {
 		await runRoute("help");
 		return;
 	}
 	while (true) {
-		const state = await describeManagerState();
-		const selected = await ctx.ui.select(state.title, state.actions);
+		const state = await describeManagerState(sessionSignal);
+		if (sessionSignal?.aborted) return;
+		const selected = await ctx.ui.select(state.title, state.actions, { signal: sessionSignal });
+		if (sessionSignal?.aborted) return;
 		if (!selected) return;
 		switch (
-			selected as MainMenuAction | ContextualMenuAction | "Set up sync" | "Use existing settings"
+			selected as
+				| MainMenuAction
+				| "Sync setups…"
+				| "Storage connections…"
+				| "History & recovery…"
+				| "Help"
+				| "Set up sync"
+				| "Use existing settings"
 		) {
 			case "Sync now (recommended)":
-				await runCancellableOperation(ctx, "Checking current target…", "sync", runRoute, true);
-				break;
-			case "Pull from remote": {
-				const result = await runCancellableOperation(
-					ctx,
-					"Checking remote changes…",
-					"pull",
-					runRoute,
-					true,
-					"Pull check cancelled; no local files were changed.",
-				);
-				if (result === "applied") return;
-				break;
-			}
-			case "Push to remote":
-				await runCancellableOperation(
-					ctx,
-					"Preparing push preview…",
-					"push",
-					runRoute,
-					true,
-					"Push preparation cancelled; no remote files were changed.",
-				);
+				await runCancellableOperation(ctx, "Checking current sync setup…", "sync", runRoute, true);
 				break;
-			case "Switch target": {
-				const result = await showTargetSwitcher(ctx, runRoute);
+			case "Switch sync setup": {
+				const result = await showSetupSwitcher(ctx, runRoute, undefined, sessionSignal);
 				if (result === "pull-attempted") return;
 				if (result === "switched") continue;
 				break;
 			}
 			case "Status & changes":
-				await runCancellableOperation(ctx, "Checking current target…", "diff", runRoute);
+				await runCancellableOperation(ctx, "Checking current sync setup…", "diff", runRoute);
 				break;
 			case "Settings":
-				await showSyncSettings(ctx, runRoute);
+				await showSyncSettings(ctx, runRoute, sessionSignal);
 				break;
 			case "More…":
-				if ((await showMoreMenu(ctx, runRoute)) === "exit") return;
+				if ((await showMoreMenu(ctx, runRoute, sessionSignal)) === "exit") return;
 				break;
-			case "Manage targets & storage":
-				await showManageMenu(ctx, runRoute);
+			case "Sync setups…":
+				if ((await showSyncSetupManager(ctx, runRoute, sessionSignal)) === "exit") return;
 				break;
-			case "History & recovery":
+			case "Storage connections…":
+				await showStorageConnections(ctx, sessionSignal);
+				break;
+			case "History & recovery…":
 				await showRecoveryMenu(ctx, runRoute);
 				break;
 			case "Help":
@@ -128,11 +125,39 @@ export async function showSyncManager(
 	}
 }
 
-async function showMoreMenu(ctx: ExtensionCommandContext, runRoute: RunRoute) {
-	const selected = await ctx.ui.select("More options", [...MORE_MENU_ACTIONS]);
+async function showMoreMenu(
+	ctx: ExtensionCommandContext,
+	runRoute: RunRoute,
+	signal?: AbortSignal,
+) {
+	const selected = await ctx.ui.select("More options", [...MORE_MENU_ACTIONS], { signal });
 	if (!selected || selected === BACK) return;
-	if (selected === "Manage targets & storage") await showManageMenu(ctx, runRoute);
-	else if (selected === "History & recovery") await showRecoveryMenu(ctx, runRoute);
+	if (selected === "Pull from remote…") {
+		const result = await runCancellableOperation(
+			ctx,
+			"Checking remote changes…",
+			"pull",
+			runRoute,
+			true,
+			"Pull check cancelled; no local files were changed.",
+		);
+		if (result === "applied") return "exit" as const;
+		return;
+	}
+	if (selected === "Push to remote…") {
+		await runCancellableOperation(
+			ctx,
+			"Preparing push preview…",
+			"push",
+			runRoute,
+			true,
+			"Push preparation cancelled; no remote files were changed.",
+		);
+		return;
+	}
+	if (selected === "Sync setups…") return showSyncSetupManager(ctx, runRoute, signal);
+	else if (selected === "Storage connections…") await showStorageConnections(ctx, signal);
+	else if (selected === "History & recovery…") await showRecoveryMenu(ctx, runRoute);
 	else {
 		await runRoute("help");
 		return "exit" as const;
@@ -153,7 +178,7 @@ async function runCancellableOperation(
 	}
 	let commitStarted = false;
 	let operation: Promise<void> | undefined;
-	let routeResult: TargetPullOutcome | undefined;
+	let routeResult: SetupPullOutcome | undefined;
 	const result = await ctx.ui.custom<{ cancelled?: boolean; error?: unknown }>(
 		(tui, theme, _kb, done) => {
 			const loader = new BorderedLoader(tui, theme, message, { cancellable: true });
@@ -194,14 +219,16 @@ async function runCancellableOperation(
 	return routeResult;
 }
 
-async function describeManagerState(): Promise<{ title: string; actions: string[] }> {
+async function describeManagerState(
+	signal?: AbortSignal,
+): Promise<{ title: string; actions: string[] }> {
 	let raw: Record<string, unknown> | undefined;
 	try {
 		raw = await readLocalConfigObject();
 	} catch (error) {
 		return {
 			title: [
-				"Pi Sync",
+				"Manage sync",
 				"",
 				"Settings file needs repair. Automatic sync and settings writes are paused.",
 				`Error: ${safeTerminalText(errorMessage(error))}`,
@@ -214,36 +241,37 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 	}
 	if (!raw) {
 		return {
-			title: ["Pi Sync", "", "Not set up.", "", "What do you want to do?"].join("\n"),
+			title: ["Manage sync", "", "Not set up.", "", "What do you want to do?"].join("\n"),
 			actions: ["Set up sync", "Help"],
 		};
 	}
-	const configuredTargets = ownRecord(raw.targets);
-	if (raw.version === 2 && configuredTargets && Object.keys(configuredTargets).length === 0) {
+	const configuredTargets = ownRecord(raw.syncSetups);
+	if (raw.version === 3 && configuredTargets && Object.keys(configuredTargets).length === 0) {
 		return {
 			title: [
-				"Pi Sync",
+				"Manage sync",
 				"",
-				"No sync targets are configured.",
-				"Add a target using an existing storage profile.",
+				"No sync setups are configured.",
+				"Add a sync setup using an existing storage connection.",
 				"",
 				"What do you want to do?",
 			].join("\n"),
-			actions: ["Manage targets & storage", "Help"],
+			actions: ["Sync setups…", "Storage connections…", "Help"],
 		};
 	}
 	try {
 		const config = await loadConfig();
-		const target = config.target ?? "default";
-		const storage = storageDescription(config.storageKind, config.endpoint, config.bucket);
-		const warnings = deprecatedPiSyncEnvironmentWarnings();
+		const target = config.setupName;
+		const storage = backendStorageDescription(config);
+		const warnings: string[] = [];
 		const lock = await inspectLock();
 		const liveLock = lock.status === "valid" && !isStaleLock(lock.lock);
 		const recoverableLock =
 			lock.status === "unreadable" || (lock.status === "valid" && isStaleLock(lock.lock));
-		const builtInCount = normalizeSyncFiles(config.syncFiles).length;
-		const extraFileCount = config.extraFiles.length;
-		const noSyncedContent = builtInCount === 0 && extraFileCount === 0 && !config.syncSessions;
+		const selection = syncIncludeSelection(config.include);
+		const builtInCount = selection.builtIns.length;
+		const extraFileCount = selection.custom.length;
+		const noSyncedContent = config.include.length === 0;
 		const stateReadDisabled = liveLock || recoverableLock;
 		const syncState = stateReadDisabled
 			? undefined
@@ -255,19 +283,26 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 				: syncState
 					? "Never synced"
 					: "Unavailable";
+		const canSwitch = (await countValidSyncSetups(configuredTargets, signal)) > 1;
+		const mainActions = MAIN_MENU_ACTIONS.filter(
+			(action) => action !== "Switch sync setup" || canSwitch,
+		);
 		return {
 			title: [
-				"Pi Sync",
+				"Manage sync",
 				"",
-				`Current target: ${safeTerminalText(target)}`,
+				`Current sync setup: ${safeTerminalText(target)}`,
 				`Storage: ${storage}`,
-				`Synced content: ${builtInCount} built-in group${builtInCount === 1 ? "" : "s"} · ${extraFileCount} extra file${extraFileCount === 1 ? "" : "s"} · Sessions: ${config.syncSessions ? "On" : "Off"}`,
-				`Auto-sync: ${config.autoSync ? "On" : "Off"}`,
-				`Last applied snapshot: ${lastAppliedSnapshot}`,
-				"Remote changes: Not checked",
+				`Included: ${builtInCount} built-in group${builtInCount === 1 ? "" : "s"} · ${extraFileCount} extra path${extraFileCount === 1 ? "" : "s"} · Sessions ${selection.sessions ? "on" : "off"}`,
+				`Automatic sync: ${config.automatic ? "On" : "Off"}`,
+				`Last applied: ${lastAppliedSnapshot}`,
+				"Remote status: Not checked",
 				...warnings.map((warning) => `Warning: ${safeTerminalText(warning)}`),
 				...(noSyncedContent
-					? ["", "No synced content is selected. Choose synced content in Settings before syncing."]
+					? [
+							"",
+							"No included content is selected. Choose included content in Settings before syncing.",
+						]
 					: []),
 				...(liveLock
 					? [
@@ -283,483 +318,492 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 			].join("\n"),
 			actions:
 				liveLock || recoverableLock
-					? ["Status & changes", "History & recovery", "Help"]
+					? ["Status & changes", "History & recovery…", "Help"]
 					: noSyncedContent
-						? ["Settings", "Switch target", "Status & changes", "More…"]
-						: [...MAIN_MENU_ACTIONS],
+						? ["Settings", ...(canSwitch ? ["Switch sync setup"] : []), "Status & changes", "More…"]
+						: mainActions,
 		};
 	} catch (error) {
-		const targets = ownRecord(raw.targets);
+		if (signal?.aborted) throw error;
 		return {
 			title: [
-				"Pi Sync",
+				"Manage sync",
 				"",
 				"Settings need attention. Automatic sync is paused.",
-				`Current target: ${safeTerminalText(typeof raw.activeTarget === "string" ? raw.activeTarget : "default")}`,
+				`Current sync setup: ${safeTerminalText(typeof raw.activeSyncSetup === "string" ? raw.activeSyncSetup : "none")}`,
 				`Error: ${safeTerminalText(errorMessage(error))}`,
 				`File: ${safeTerminalText(await activeLocalConfigPath())}`,
 				"",
 				"What do you want to do?",
 			].join("\n"),
-			actions: [
-				...(targets && Object.keys(targets).length > 1 ? ["Switch target"] : []),
-				"Manage targets & storage",
-				"Help",
-			],
+			actions: ["Sync setups…", "Storage connections…", "History & recovery…", "Help"],
 		};
 	}
 }
 
-export async function showSetupWizard(ctx: ExtensionCommandContext) {
-	if (ctx.mode !== "tui") return false;
-	const preset = await ctx.ui.select("Set up sync\n\nWhere will Pi settings be stored?", [
-		"Cloudflare R2",
-		"Other S3-compatible storage",
-		"Cancel",
-	]);
-	if (!preset || preset === "Cancel") return false;
-	const targetName = await chooseInitialTargetName(ctx);
+function backendStorageDescription(config: AnySyncConfig) {
+	const connection = safeTerminalText(config.connectionName);
+	switch (config.backend.type) {
+		case "s3": {
+			const type =
+				config.backend.profile.kind === "r2" ||
+				isCloudflareR2Endpoint(config.backend.profile.endpoint)
+					? "Cloudflare R2"
+					: "S3-compatible";
+			return `${type} · ${connection} · ${safeTerminalText(config.backend.destination.bucket)}`;
+		}
+		case "webdav":
+			return `WebDAV · ${connection} · ${safeTerminalText(config.backend.destination.path)}`;
+		case "git":
+			return `Git · ${connection} · ${safeTerminalText(config.backend.destination.branch)}`;
+	}
+}
+
+export async function showSetupWizard(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify(
+			`Guided sync setup requires TUI mode for masked credential input. Create version 3 settings in ${safeTerminalText(localConfigPath())}.`,
+			"warning",
+		);
+		return false;
+	}
+	const preset = await ctx.ui.select(
+		"Set up sync\n\nWhere will Pi settings be stored?",
+		["Cloudflare R2", "Other S3-compatible storage", "WebDAV", "Git", "Cancel"],
+		{ signal },
+	);
+	if (signal?.aborted || !preset || preset === "Cancel") return false;
+	const targetName = await chooseInitialTargetName(ctx, signal);
 	if (!targetName) return false;
+	if (preset === "WebDAV") {
+		const saved = await showWebDavSetup(ctx, targetName, signal);
+		if (signal?.aborted) return false;
+		if (saved) await refreshTargetCompletions();
+		return saved;
+	}
+	if (preset === "Git") {
+		const saved = await showGitSetup(ctx, targetName, signal);
+		if (signal?.aborted) return false;
+		if (saved) await refreshTargetCompletions();
+		return saved;
+	}
 	const endpoint = await requiredInput(
 		ctx,
 		preset === "Cloudflare R2" ? "Cloudflare R2 endpoint" : "S3-compatible endpoint",
 		preset === "Cloudflare R2"
 			? "https://<account-id>.r2.cloudflarestorage.com"
 			: "https://s3.example.com",
+		signal,
 	);
 	if (!endpoint) return false;
 	let region = "auto";
 	if (preset !== "Cloudflare R2") {
-		const selectedRegion = await requiredInput(ctx, "Storage region", "us-east-1");
+		const selectedRegion = await requiredInput(ctx, "Storage region", "us-east-1", signal);
 		if (!selectedRegion) return false;
 		region = selectedRegion;
 	}
-	const location = await chooseInitialRemoteLocation(ctx, preset, targetName);
+	const location = await chooseInitialRemoteLocation(ctx, preset, targetName, signal);
 	if (!location) return false;
-	const { profileName, bucket, prefix, namespace } = location;
-	const credentialChoice = await ctx.ui.select(
-		"Credentials\n\nSecret values are never shown in pi-sync screens.",
-		["Use environment credentials", "Create private settings template", "Cancel"],
+	const { connectionName, bucket, path: storagePath } = location;
+	const credentials = await chooseS3Credentials(ctx, signal);
+	if (!credentials) return false;
+	const contentChoice = await ctx.ui.select(
+		"Choose an initial sync preset",
+		["Recommended Pi settings", "Minimal settings", "Cancel"],
+		{ signal },
 	);
-	if (!credentialChoice || credentialChoice === "Cancel") return false;
-	const contentChoice = await ctx.ui.select("Choose an initial sync preset", [
-		"Recommended Pi settings",
-		"Minimal settings",
-		"Cancel",
-	]);
-	if (!contentChoice || contentChoice === "Cancel") return false;
+	if (signal?.aborted || !contentChoice || contentChoice === "Cancel") return false;
 	const syncFiles =
-		contentChoice === "Minimal settings" ? ["settings.json", "AGENTS.md"] : [...DEFAULT_SYNC_FILES];
-	const automaticChoice = await ctx.ui.select("Automatic sync for this target", [
-		"Enable automatic sync",
-		"Keep automatic sync off",
-		"Cancel",
-	]);
-	if (!automaticChoice || automaticChoice === "Cancel") return false;
+		contentChoice === "Minimal settings"
+			? ["settings.json", "AGENTS.md"]
+			: [...DEFAULT_SYNC_INCLUDE];
+	const automaticChoice = await ctx.ui.select(
+		"Automatic sync for this setup",
+		["Enable automatic sync", "Keep automatic sync off", "Cancel"],
+		{ signal },
+	);
+	if (signal?.aborted || !automaticChoice || automaticChoice === "Cancel") return false;
 	const sessionChoice = await ctx.ui.select(
 		"Session conversations\n\nSessions can contain prompts, tool output, paths, screenshots, and secrets.",
 		["Keep sessions off (recommended)", "Include session conversations", "Cancel"],
+		{ signal },
 	);
-	if (!sessionChoice || sessionChoice === "Cancel") return false;
+	if (signal?.aborted || !sessionChoice || sessionChoice === "Cancel") return false;
 	const syncSessions = sessionChoice === "Include session conversations";
 	if (
 		syncSessions &&
 		!(await ctx.ui.confirm(
 			"Include session conversations?",
 			"I understand that session JSONL can contain prompts, tool output, paths, screenshots, and secrets.",
+			{ signal },
 		))
 	) {
 		return false;
 	}
 	const autoSync = automaticChoice === "Enable automatic sync";
-	const hasEnvironmentCredentials = Boolean(
-		(process.env.PI_SYNC_ACCESS_KEY_ID ?? process.env.AWS_ACCESS_KEY_ID) &&
-			(process.env.PI_SYNC_SECRET_ACCESS_KEY ?? process.env.AWS_SECRET_ACCESS_KEY),
-	);
-	const credentialSummary =
-		credentialChoice === "Use environment credentials"
-			? hasEnvironmentCredentials
-				? "Environment credentials detected"
-				: "Environment credentials are currently missing"
-			: `Complete accessKeyId and secretAccessKey in ${localConfigPath()}`;
 	const choice = await ctx.ui.select(
 		[
-			"Review setup",
+			"Review sync setup",
 			"",
-			`Target: ${safeTerminalText(targetName)}`,
-			`Storage profile: ${safeTerminalText(profileName)} (${preset})`,
+			`Sync setup: ${safeTerminalText(targetName)}`,
+			`Storage connection: ${safeTerminalText(connectionName)} (${preset})`,
 			`Endpoint: ${safeTerminalText(endpoint)}`,
 			`Bucket: ${safeTerminalText(bucket)}`,
-			`Remote path: ${formatRemotePath(prefix, namespace)}`,
+			`Storage location: ${safeTerminalText(storagePath)}`,
 			"Bucket must already exist. pi-sync will not create it.",
-			`Synced content: ${syncFiles.length} built-in groups · Sessions: ${syncSessions ? "On — privacy warning acknowledged" : "Off"}`,
-			`Auto-sync: ${autoSync ? "On" : "Off"}`,
-			`Credentials: ${safeTerminalText(credentialSummary)}`,
+			`Included content: ${syncFiles.length} built-in groups · Sessions: ${syncSessions ? "On — privacy warning acknowledged" : "Off"}`,
+			`Automatic sync: ${autoSync ? "On" : "Off"}`,
+			`Credentials: ${safeTerminalText(credentials.summary)}`,
 		].join("\n"),
-		["Save setup", "Cancel"],
+		["Save sync setup", "Cancel"],
+		{ signal },
 	);
-	if (choice !== "Save setup") return false;
-	await saveNewV2Settings({
-		targetName,
-		storageProfileName: profileName,
-		profile: {
-			kind: preset === "Cloudflare R2" ? "r2" : "s3-compatible",
-			endpoint,
-			region,
-		},
-		target: {
-			bucket,
-			prefix,
-			namespace,
-			autoSync,
-			syncFiles,
-			syncSessions,
-			extraFiles: [],
+	if (signal?.aborted || choice !== "Save sync setup") return false;
+	await saveNewV3Settings(
+		{
+			setupName: targetName,
+			connectionName,
+			connection: {
+				type: "s3",
+				endpoint,
+				region,
+				credentials: {
+					accessKeyId: credentials.profileFields.accessKeyId ?? "",
+					secretAccessKey: credentials.profileFields.secretAccessKey ?? "",
+				},
+			},
+			setup: {
+				storage: { connection: connectionName, bucket, path: storagePath },
+				sync: {
+					include: [...syncFiles, ...(syncSessions ? ["sessions"] : [])],
+					automatic: autoSync,
+				},
+			},
 		},
-	});
+		signal,
+	);
+	if (signal?.aborted) return false;
 	await refreshTargetCompletions();
+	if (signal?.aborted) return true;
 	ctx.ui.notify(
-		hasEnvironmentCredentials || credentialChoice !== "Use environment credentials"
-			? `Target “${safeTerminalText(targetName)}” is ready. Use Sync now when ready.`
-			: `Saved target “${safeTerminalText(targetName)}”; add credentials before syncing.`,
+		credentials.ready
+			? `Sync setup “${safeTerminalText(targetName)}” is ready. Use Sync now when ready.`
+			: `Saved sync setup “${safeTerminalText(targetName)}”; add credentials before syncing.`,
 		"info",
 	);
 	return true;
 }
 
-async function showTargetSwitcher(ctx: ExtensionCommandContext, runRoute: RunRoute) {
+async function showSetupSwitcher(
+	ctx: ExtensionCommandContext,
+	runRoute: RunRoute,
+	selectedName?: string,
+	signal?: AbortSignal,
+) {
 	const raw = await readLocalConfigObject();
-	if (raw?.version !== 2) {
-		ctx.ui.notify("Add a second sync target before switching targets.", "info");
+	if (signal?.aborted) return false;
+	if (raw?.version !== 3) {
+		ctx.ui.notify("Add a second sync setup before switching setups.", "info");
 		return false;
 	}
-	const targets = ownRecord(raw.targets);
+	const targets = ownRecord(raw.syncSetups);
 	if (!targets) {
-		ctx.ui.notify("No sync targets are configured.", "warning");
+		ctx.ui.notify("No sync setups are configured.", "warning");
+		return false;
+	}
+	const active = typeof raw.activeSyncSetup === "string" ? raw.activeSyncSetup : undefined;
+	let name = selectedName;
+	if (!name) {
+		const profiles = ownRecord(raw.storageConnections);
+		const labels = new Map<string, string>();
+		for (const candidate of Object.keys(targets).sort((left, right) => left.localeCompare(right))) {
+			const target = ownRecord(targets[candidate]);
+			const storage = ownRecord(target?.storage);
+			const profileName = typeof storage?.connection === "string" ? storage.connection : undefined;
+			const profile = profileName && profiles ? ownRecord(profiles[profileName]) : undefined;
+			const location = profile
+				? profile.type === "git"
+					? `${String(storage?.branch ?? "missing branch")}:${String(storage?.path ?? "missing path")}`
+					: profile.type === "s3"
+						? `${String(storage?.bucket ?? "missing bucket")}/${String(storage?.path ?? "missing path")}`
+						: String(storage?.path ?? "missing path")
+				: `invalid: missing connection ${profileName ?? "reference"}`;
+			const label = `${safeTerminalText(candidate)}${candidate === active ? " (current)" : ""} · ${safeTerminalText(profileName ?? "unknown")} · ${safeTerminalText(location)}`;
+			labels.set(label, candidate);
+		}
+		const selected = await ctx.ui.select(
+			`Switch sync setup\n\nCurrent sync setup: ${safeTerminalText(active ?? "none")}`,
+			[...labels.keys(), BACK],
+			{ signal },
+		);
+		if (!selected || selected === BACK) return false;
+		name = labels.get(selected);
+	}
+	if (!name || !Object.hasOwn(targets, name)) {
+		ctx.ui.notify(
+			`Sync setup “${safeTerminalText(name ?? "unknown")}” no longer exists.`,
+			"warning",
+		);
 		return false;
 	}
-	const active = typeof raw.activeTarget === "string" ? raw.activeTarget : undefined;
-	const profiles = ownRecord(raw.profiles);
-	const names = Object.keys(targets).sort((left, right) => left.localeCompare(right));
-	const labels = new Map<string, string>();
-	for (const name of names) {
-		const target = ownRecord(targets[name]);
-		const profileName = typeof target?.profile === "string" ? target.profile : undefined;
-		const profile = profileName && profiles ? ownRecord(profiles[profileName]) : undefined;
-		const label = [
-			`${safeTerminalText(name)}${name === active ? " (current)" : ""}`,
-			profile
-				? `${safeTerminalText(profileName ?? "unknown")} · ${safeTerminalText(String(target?.bucket ?? "missing bucket"))}`
-				: `Invalid: missing storage profile ${safeTerminalText(profileName ?? "reference")}`,
-			`${normalizeSyncFiles(target?.syncFiles as string[] | undefined).length} groups · Sessions: ${target?.syncSessions === true ? "On" : "Off"}`,
-		].join(" · ");
-		labels.set(label, name);
-	}
-	const options = [...labels.keys(), BACK];
-	const selected = await ctx.ui.select(
-		`Switch target\n\nCurrent target: ${safeTerminalText(active ?? "none")}`,
-		options,
-	);
-	if (!selected || selected === BACK) return false;
-	const name = labels.get(selected) ?? selected.replace(/ \(current\)$/u, "");
 	if (name === active) {
-		ctx.ui.notify(`Target “${safeTerminalText(name)}” is already current.`, "info");
+		ctx.ui.notify(`Sync setup “${safeTerminalText(name)}” is already current.`, "info");
 		return false;
 	}
-	let config: SyncConfig;
+	let config: AnySyncConfig;
 	try {
 		config = await loadConfig(name);
+		if (signal?.aborted) return false;
 	} catch (error) {
 		ctx.ui.notify(
-			`Cannot use target “${safeTerminalText(name)}”: ${safeTerminalText(errorMessage(error))}`,
+			`Cannot use sync setup “${safeTerminalText(name)}”: ${safeTerminalText(errorMessage(error))}`,
 			"error",
 		);
 		return false;
 	}
-	const targetSwitchAction = await loadTargetSwitchAction();
+	const onSwitch = await loadOnSwitch();
+	if (signal?.aborted) return false;
 	const switchEffect =
-		targetSwitchAction === "ask"
-			? "After switching, pi-sync will ask whether to review a pull for the target."
-			: targetSwitchAction === "pull"
-				? "After switching, pi-sync will check the target and show exact changes before applying them."
+		onSwitch === "ask-before-pull"
+			? "After switching, pi-sync will ask whether to review a pull for this setup."
+			: onSwitch === "pull-after-switch"
+				? "After switching, pi-sync will check this setup and show exact changes before applying them."
 				: "After switching, pi-sync will not pull or modify synced files.";
 	const choice = await ctx.ui.select(
 		[
-			"Switch target",
+			"Switch sync setup",
 			"",
 			`From: ${safeTerminalText(active ?? "none")}`,
 			`To: ${safeTerminalText(name)}`,
-			`Storage: ${storageDescription(config.storageKind, config.endpoint, config.bucket)}`,
-			`Synced content: ${normalizeSyncFiles(config.syncFiles).length} built-in groups · ${config.extraFiles.length} extra files`,
-			`Auto-sync: ${config.autoSync ? "On" : "Off"} · Sessions: ${config.syncSessions ? "On" : "Off"}`,
+			`Storage: ${backendStorageDescription(config)}`,
+			`Included content: ${config.include.length} paths`,
+			`Automatic sync: ${config.automatic ? "On" : "Off"} · Sessions: ${config.include.includes("sessions") ? "On" : "Off"}`,
 			"",
 			switchEffect,
 		].join("\n"),
 		[`Switch to ${safeTerminalText(name)}`, "Cancel"],
+		{ signal },
 	);
-	if (choice !== `Switch to ${safeTerminalText(name)}`) return false;
-	const result = await useSyncTarget(ctx, name, (selectedTarget) =>
-		runCancellableOperation(
+	if (signal?.aborted || choice !== `Switch to ${safeTerminalText(name)}`) return false;
+	try {
+		const result = await useSyncSetup(
 			ctx,
-			`Pulling target “${safeTerminalText(name)}”…`,
-			"pull",
-			runRoute,
-			true,
-			null,
-			selectedTarget,
-		),
-	);
-	return result.pullApplied ? "pull-attempted" : "switched";
+			name,
+			(selectedTarget) =>
+				runCancellableOperation(
+					ctx,
+					`Pulling sync setup “${safeTerminalText(name)}”…`,
+					"pull",
+					runRoute,
+					true,
+					null,
+					selectedTarget,
+				),
+			onSwitch,
+			signal,
+			syncConfigReviewIdentity(config),
+		);
+		return result.pullApplied ? "pull-attempted" : "switched";
+	} catch (error) {
+		if (signal?.aborted) return false;
+		ctx.ui.notify(
+			`Sync setup “${safeTerminalText(name)}” was not switched: ${safeTerminalText(errorMessage(error))}`,
+			"error",
+		);
+		return false;
+	}
 }
 
-async function showManageMenu(ctx: ExtensionCommandContext, _runRoute: RunRoute) {
-	const selected = await ctx.ui.select("Manage targets & storage", [
-		"Add sync target",
-		"Edit current target",
-		"Manage storage profiles",
-		"Remove sync target",
-		BACK,
-	]);
-	if (!selected || selected === BACK) return;
-	if (selected === "Add sync target") await showAddTarget(ctx);
-	else if (selected === "Edit current target") await showEditCurrentTarget(ctx);
-	else if (selected === "Manage storage profiles") await showStorageProfiles(ctx);
-	else await showRemoveTarget(ctx);
+async function showSyncSetupManager(
+	ctx: ExtensionCommandContext,
+	runRoute: RunRoute,
+	signal?: AbortSignal,
+) {
+	return showSyncSetups(
+		ctx,
+		{
+			add: async (setupSignal) => {
+				await showAddTarget(ctx, setupSignal);
+			},
+			edit: async (name, setupSignal) => {
+				await showEditTarget(ctx, name, setupSignal);
+			},
+			makeCurrent: async (name, setupSignal) => {
+				const result = await showSetupSwitcher(ctx, runRoute, name, setupSignal);
+				return result === "pull-attempted" ? "exit" : undefined;
+			},
+			remove: async (name, setupSignal) => {
+				await showRemoveTarget(ctx, name, setupSignal);
+			},
+		},
+		signal,
+	);
 }
 
-async function showAddTarget(ctx: ExtensionCommandContext) {
+async function showAddTarget(ctx: ExtensionCommandContext, signal?: AbortSignal) {
 	let raw = await readLocalConfigObject();
-	if (!raw)
-		return void ctx.ui.notify("Set up the first sync target before adding another.", "info");
-	if (raw.version !== 2) {
-		const choice = await ctx.ui.select(
-			[
-				"Upgrade settings for multiple targets",
-				"",
-				"The existing destination, unknown fields, and local sync state will be preserved.",
-				"An exact private backup is created before the atomic conversion.",
-			].join("\n"),
-			["Upgrade settings", "Cancel"],
-		);
-		if (choice !== "Upgrade settings") return;
-		const currentTarget = await requiredInput(ctx, "Name the existing sync target", "default");
-		if (!currentTarget) return;
-		const currentProfile = await requiredInput(ctx, "Name the existing storage profile", "default");
-		if (!currentProfile) return;
-		const migration = await migrateLegacySettings(currentTarget, currentProfile);
+	if (signal?.aborted) return;
+	if (!raw) return void ctx.ui.notify("Set up the first sync setup before adding another.", "info");
+	if (raw.version !== 3) {
 		ctx.ui.notify(
-			`Upgraded pi-sync settings. Backup: ${safeTerminalText(migration.backupPath)}`,
-			"info",
+			"Version 1 and version 2 settings are unsupported and are never migrated.",
+			"error",
 		);
-		raw = migration.settings;
-	}
-	const profiles = ownRecord(raw.profiles);
-	if (!profiles || Object.keys(profiles).length === 0) {
-		ctx.ui.notify("Add a storage profile before adding a sync target.", "warning");
 		return;
 	}
-	const name = await requiredInput(ctx, "Name the new sync target", "work");
+	let profiles = ownRecord(raw.storageConnections) ?? {};
+	const name = await requiredInput(ctx, "Name the new sync setup", "work", signal);
 	if (!name) return;
-	const profile = await ctx.ui.select("Choose storage for this target", [
-		...Object.keys(profiles).sort(),
-		"Cancel",
-	]);
+	const createConnection = "Add a new storage connection…";
+	let profile = await ctx.ui.select(
+		"Choose a storage connection",
+		[...Object.keys(profiles).sort(), createConnection, "Cancel"],
+		{ signal },
+	);
 	if (!profile || profile === "Cancel") return;
-	const location = await chooseAdditionalRemoteLocation(ctx, raw, profile, name);
+	if (profile === createConnection) {
+		const previousNames = new Set(Object.keys(profiles));
+		if (!(await showAddStorageConnection(ctx, signal))) return;
+		if (signal?.aborted) return;
+		raw = (await readLocalConfigObject()) ?? raw;
+		if (signal?.aborted) return;
+		profiles = ownRecord(raw.storageConnections) ?? {};
+		profile = Object.keys(profiles).find((candidate) => !previousNames.has(candidate));
+		if (!profile) return;
+	}
+	const storageKind = ownRecord(profiles[profile])?.type;
+	if (storageKind === "webdav") {
+		const saved = await showAddWebDavTarget(ctx, name, profile, signal);
+		if (signal?.aborted) return;
+		if (saved) await refreshTargetCompletions();
+		return;
+	}
+	if (storageKind === "git") {
+		const saved = await showAddGitTarget(ctx, name, profile, signal);
+		if (signal?.aborted) return;
+		if (saved) await refreshTargetCompletions();
+		return;
+	}
+	const location = await chooseAdditionalRemoteLocation(ctx, raw, profile, name, signal);
 	if (!location) return;
-	const { bucket, prefix, namespace } = location;
-	const preset = await ctx.ui.select("Choose synced content", [
-		"Recommended Pi settings",
-		"Minimal settings",
-		"Cancel",
-	]);
+	const { bucket, path: storagePath } = location;
+	const preset = await ctx.ui.select(
+		"Choose included content",
+		["Recommended Pi settings", "Minimal settings", "Cancel"],
+		{ signal },
+	);
 	if (!preset || preset === "Cancel") return;
 	const syncFiles =
-		preset === "Minimal settings" ? ["settings.json", "AGENTS.md"] : [...DEFAULT_SYNC_FILES];
-	const overlapsExistingTarget = Object.values(ownRecord(raw.targets) ?? {}).some((value) => {
-		const existing =
-			value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
-		const selected = normalizeSyncFiles(existing?.syncFiles as string[] | undefined);
+		preset === "Minimal settings" ? ["settings.json", "AGENTS.md"] : [...DEFAULT_SYNC_INCLUDE];
+	const overlapsExistingTarget = Object.values(ownRecord(raw.syncSetups) ?? {}).some((value) => {
+		const existing = ownRecord(value);
+		const sync = ownRecord(existing?.sync);
+		const selected = syncIncludeSelection(
+			Array.isArray(sync?.include) ? sync.include : [],
+		).builtIns;
 		return selected.some((item) => syncFiles.includes(item));
 	});
 	const choice = await ctx.ui.select(
 		[
-			"Review new sync target",
+			"Review new sync setup",
 			"",
-			`Target: ${safeTerminalText(name)}`,
-			`Storage profile: ${safeTerminalText(profile)}`,
+			`Sync setup: ${safeTerminalText(name)}`,
+			`Storage connection: ${safeTerminalText(profile)}`,
 			`Bucket: ${safeTerminalText(bucket)}`,
-			`Remote path: ${formatRemotePath(prefix, namespace)}`,
+			`Storage location: ${safeTerminalText(storagePath)}`,
 			"Bucket must already exist. pi-sync will not create it.",
-			`Synced content: ${syncFiles.length} built-in groups · Sessions: Off`,
+			`Included content: ${syncFiles.length} built-in groups · Sessions: Off`,
 			...(overlapsExistingTarget
 				? [
-						"Warning: this target shares local content with another target; only the current target auto-syncs.",
+						"Warning: this setup shares local content with another setup; only the current setup syncs automatically.",
 					]
 				: []),
-			"Switching to this target later will not sync automatically.",
+			"Adding this setup does not sync or modify remote data.",
 		].join("\n"),
-		["Add target", "Cancel"],
+		["Add sync setup", "Cancel"],
+		{ signal },
 	);
-	if (choice !== "Add target") return;
-	await addSyncTarget(name, {
-		profile,
-		bucket,
-		prefix,
-		namespace,
-		autoSync: true,
-		syncFiles,
-		syncSessions: false,
-		extraFiles: [],
-	});
+	if (signal?.aborted || choice !== "Add sync setup") return;
+	await addSyncSetup(
+		name,
+		{
+			storage: { connection: profile, bucket, path: storagePath },
+			sync: { include: syncFiles, automatic: true },
+		},
+		signal,
+	);
+	if (signal?.aborted) return;
 	await refreshTargetCompletions();
-	ctx.ui.notify(`Added sync target “${safeTerminalText(name)}”.`, "info");
+	ctx.ui.notify(`Added sync setup “${safeTerminalText(name)}”.`, "info");
 }
 
-async function showEditCurrentTarget(ctx: ExtensionCommandContext) {
-	const partial = await loadPartialConfig();
-	if (partial.settingsVersion !== 2 || !partial.target) {
-		ctx.ui.notify("Upgrade settings before editing a named target.", "info");
+async function showEditTarget(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
+	const partial = await loadPartialConfig(name);
+	if (signal?.aborted) return;
+	if (!partial.setupName) {
+		ctx.ui.notify("Create version 3 settings before editing a named sync setup.", "info");
 		return;
 	}
-	const bucket = await requiredInput(ctx, "Bucket", partial.bucket ?? "pi-sync");
+	if (partial.storageKind === "webdav") {
+		await showEditWebDavTarget(ctx, partial, signal);
+		return;
+	}
+	if (partial.storageKind === "git") {
+		await showEditGitTarget(ctx, partial, signal);
+		return;
+	}
+	const bucket = await requiredInput(ctx, "Bucket", partial.bucket ?? "pi-sync", signal);
 	if (!bucket) return;
-	const prefix = await requiredInput(ctx, "Remote prefix", partial.prefix ?? "pi-sync");
-	if (!prefix) return;
-	const namespace = await requiredInput(ctx, "Remote namespace", partial.profile ?? partial.target);
-	if (!namespace) return;
+	const storagePath = await requiredInput(ctx, "Storage path", partial.storagePath, signal);
+	if (!storagePath) return;
+	const normalizedPath = storagePath.replace(/^\/+|\/+$/gu, "");
 	const choice = await ctx.ui.select(
 		[
-			`Review target “${safeTerminalText(partial.target)}”`,
+			`Review sync setup “${safeTerminalText(partial.setupName)}”`,
 			"",
 			`Bucket: ${safeTerminalText(partial.bucket ?? "missing")} → ${safeTerminalText(bucket)}`,
-			`Prefix: ${safeTerminalText(partial.prefix ?? "pi-sync")} → ${safeTerminalText(prefix)}`,
-			`Namespace: ${safeTerminalText(partial.profile ?? partial.target)} → ${safeTerminalText(namespace)}`,
-			"Saving changes future sync destination only; it does not move or delete remote data.",
+			`Storage path: ${safeTerminalText(partial.storagePath ?? "missing")} → ${safeTerminalText(normalizedPath)}`,
+			"Saving changes the future storage location only; it does not move or delete remote data.",
 		].join("\n"),
-		["Save target", "Cancel"],
-	);
-	if (choice !== "Save target") return;
-	await updateSyncTarget(partial.target, (target) => ({ ...target, bucket, prefix, namespace }));
-	ctx.ui.notify(`Saved target “${safeTerminalText(partial.target)}”.`, "info");
-}
-
-async function showStorageProfiles(ctx: ExtensionCommandContext) {
-	const raw = await readLocalConfigObject();
-	if (raw?.version !== 2) {
-		ctx.ui.notify("Upgrade settings before managing storage profiles.", "info");
-		return;
-	}
-	const profiles = ownRecord(raw.profiles) ?? {};
-	const selected = await ctx.ui.select("Storage profiles", [
-		"Add storage profile",
-		...Object.keys(profiles).sort(),
-		BACK,
-	]);
-	if (!selected || selected === BACK) return;
-	if (selected === "Add storage profile") {
-		await showAddStorageProfile(ctx);
-		return;
-	}
-	const action = await ctx.ui.select(`Storage profile “${safeTerminalText(selected)}”`, [
-		"Edit connection",
-		"Remove storage profile",
-		BACK,
-	]);
-	if (!action || action === BACK) return;
-	if (action === "Remove storage profile") {
-		const confirmed = await ctx.ui.confirm(
-			"Remove storage profile?",
-			`Remove local profile “${safeTerminalText(selected)}”? Remote buckets and snapshots are not deleted.`,
-		);
-		if (!confirmed) return;
-		await removeStorageProfile(selected);
-		ctx.ui.notify(`Removed storage profile “${safeTerminalText(selected)}”.`, "info");
-		return;
-	}
-	const profile = ownRecord(profiles[selected]);
-	if (!profile) return;
-	const endpoint = await requiredInput(
-		ctx,
-		"Endpoint",
-		String(profile.endpoint ?? "https://s3.example.com"),
-	);
-	if (!endpoint) return;
-	const region = await requiredInput(ctx, "Region", String(profile.region ?? "auto"));
-	if (!region) return;
-	const save = await ctx.ui.select(
-		`Review connection\n\nProfile: ${safeTerminalText(selected)}\nEndpoint: ${safeTerminalText(endpoint)}\nRegion: ${safeTerminalText(region)}\nCredentials remain unchanged and are never shown.`,
-		["Save profile", "Cancel"],
+		["Save sync setup", "Cancel"],
+		{ signal },
 	);
-	if (save !== "Save profile") return;
-	await updateStorageProfile(selected, (current) => ({ ...current, endpoint, region }));
-	ctx.ui.notify(`Saved storage profile “${safeTerminalText(selected)}”.`, "info");
-}
-
-async function showAddStorageProfile(ctx: ExtensionCommandContext) {
-	const preset = await ctx.ui.select("Storage type", [
-		"Cloudflare R2",
-		"Other S3-compatible storage",
-		"Cancel",
-	]);
-	if (!preset || preset === "Cancel") return;
-	const name = await requiredInput(
-		ctx,
-		"Name the storage profile",
-		preset === "Cloudflare R2" ? "r2" : "s3",
-	);
-	if (!name) return;
-	const endpoint = await requiredInput(
-		ctx,
-		"Endpoint",
-		preset === "Cloudflare R2"
-			? "https://<account-id>.r2.cloudflarestorage.com"
-			: "https://s3.example.com",
-	);
-	if (!endpoint) return;
-	const region =
-		preset === "Cloudflare R2" ? "auto" : await requiredInput(ctx, "Region", "us-east-1");
-	if (!region) return;
-	const save = await ctx.ui.select(
-		`Review storage profile\n\nName: ${safeTerminalText(name)}\nType: ${preset}\nEndpoint: ${safeTerminalText(endpoint)}\nRegion: ${safeTerminalText(region)}\nAdd credentials privately in ${safeTerminalText(localConfigPath())} or use environment credentials.`,
-		["Add profile", "Cancel"],
+	if (signal?.aborted || choice !== "Save sync setup") return;
+	await updateSyncSetup(
+		partial.setupName,
+		(setup) => {
+			if (typeof setup.storage.bucket !== "string") {
+				throw new Error("Sync setup storage type changed; reopen it.");
+			}
+			return {
+				...setup,
+				storage: { ...setup.storage, bucket, path: normalizedPath },
+			};
+		},
+		{ expectedStorage: partial, signal },
 	);
-	if (save !== "Add profile") return;
-	await addStorageProfile(name, {
-		kind: preset === "Cloudflare R2" ? "r2" : "s3-compatible",
-		endpoint,
-		region,
-	});
-	ctx.ui.notify(`Added storage profile “${safeTerminalText(name)}”.`, "info");
+	if (signal?.aborted) return;
+	ctx.ui.notify(`Saved sync setup “${safeTerminalText(partial.setupName)}”.`, "info");
 }
 
-async function showRemoveTarget(ctx: ExtensionCommandContext) {
-	const raw = await readLocalConfigObject();
-	const targets = ownRecord(raw?.targets);
-	if (raw?.version !== 2 || !targets || Object.keys(targets).length === 0) {
-		ctx.ui.notify("No named sync targets are available to remove.", "info");
-		return;
-	}
-	const selected = await ctx.ui.select("Remove sync target", [
-		...Object.keys(targets).sort(),
-		"Cancel",
-	]);
-	if (!selected || selected === "Cancel") return;
+async function showRemoveTarget(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
 	const confirmed = await ctx.ui.confirm(
-		"Remove sync target?",
-		`Remove local target “${safeTerminalText(selected)}”? Remote buckets and snapshots are not deleted.`,
+		"Remove sync setup?",
+		`Remove local sync setup “${safeTerminalText(name)}”? Remote data and history are not deleted.`,
+		{ signal },
 	);
-	if (!confirmed) return;
-	await removeSyncTarget(selected);
+	if (signal?.aborted || !confirmed) return;
+	await removeSyncSetup(name, signal);
+	if (signal?.aborted) return;
 	await refreshTargetCompletions();
 	ctx.ui.notify(
-		`Removed sync target “${safeTerminalText(selected)}”; remote data was not deleted.`,
+		`Removed sync setup “${safeTerminalText(name)}”; remote data was not deleted.`,
 		"info",
 	);
 }
 
 async function refreshTargetCompletions() {
-	setSyncTargetCompletions(await configuredTargetNames());
+	setSyncSetupCompletions(await configuredSyncSetupNames());
 }
 
 async function showRecoveryMenu(ctx: ExtensionCommandContext, runRoute: RunRoute) {
@@ -779,60 +823,59 @@ async function showRecoveryMenu(ctx: ExtensionCommandContext, runRoute: RunRoute
 }
 
 interface ChosenRemoteLocation {
-	profileName: string;
+	connectionName: string;
 	bucket: string;
-	prefix: string;
-	namespace: string;
+	path: string;
 }
 
-async function chooseInitialTargetName(ctx: ExtensionCommandContext) {
-	const purpose = await ctx.ui.select("What will this target be used for?", [
-		"Personal / Home",
-		"Work",
-		"Custom",
-		"Cancel",
-	]);
+async function chooseInitialTargetName(ctx: ExtensionCommandContext, signal?: AbortSignal) {
+	const purpose = await ctx.ui.select(
+		"What will this sync setup be used for?",
+		["Personal / Home", "Work", "Custom", "Cancel"],
+		{ signal },
+	);
 	if (!purpose || purpose === "Cancel") return undefined;
 	if (purpose === "Personal / Home") return "home";
 	if (purpose === "Work") return "work";
-	return requiredInput(ctx, "Name this sync target", "default");
+	return requiredInput(ctx, "Name this sync setup", "default", signal);
 }
 
 async function chooseInitialRemoteLocation(
 	ctx: ExtensionCommandContext,
 	preset: string,
-	targetName: string,
+	setupName: string,
+	signal?: AbortSignal,
 ): Promise<ChosenRemoteLocation | undefined> {
-	const profileName = preset === "Cloudflare R2" ? "r2" : "s3";
+	const connectionName = preset === "Cloudflare R2" ? "r2" : "s3";
 	const suggested = {
-		profileName,
+		connectionName,
 		bucket: "pi-sync",
-		prefix: "pi-sync",
-		namespace: targetName,
+		path: `pi-sync/${setupName}`,
 	};
 	if (preset === "Cloudflare R2") {
 		const choice = await ctx.ui.select(
 			[
-				"Choose remote location",
+				"Choose storage location",
 				"",
-				`Suggested storage profile: ${profileName}`,
+				`Suggested storage connection: ${connectionName}`,
 				`Suggested bucket: ${suggested.bucket}`,
-				`Remote path: ${formatRemotePath(suggested.prefix, suggested.namespace)}`,
+				`Remote path: ${safeTerminalText(suggested.path)}`,
 				"Bucket must already exist. pi-sync will not create it.",
 			].join("\n"),
 			["Use suggested location (recommended)", "Customize remote location", "Cancel"],
+			{ signal },
 		);
 		if (!choice || choice === "Cancel") return undefined;
 		if (choice === "Use suggested location (recommended)") return suggested;
-		return chooseCustomRemoteLocation(ctx, targetName, profileName, true);
+		return chooseCustomRemoteLocation(ctx, setupName, connectionName, true, signal);
 	}
 
 	const choice = await ctx.ui.select(
 		[
-			"Choose remote location",
+			"Choose storage location",
 			"",
-			`Suggested storage profile: ${profileName}`,
-			`Suggested path: ${formatRemotePath("pi-sync", targetName)}`,
+			`Suggested storage connection: ${connectionName}`,
+			`Suggested path: ${safeTerminalText(suggested.path)}`,
 			"S3 bucket names may need to be globally unique and the bucket must already exist.",
 		].join("\n"),
 		[
@@ -840,149 +883,101 @@ async function chooseInitialRemoteLocation(
 			"Customize remote location",
 			"Cancel",
 		],
+		{ signal },
 	);
 	if (!choice || choice === "Cancel") return undefined;
 	if (choice === "Customize remote location") {
-		return chooseCustomRemoteLocation(ctx, targetName, profileName, true);
+		return chooseCustomRemoteLocation(ctx, setupName, connectionName, true, signal);
 	}
-	const bucket = await requiredExistingBucket(ctx, "pi-sync-your-name");
+	const bucket = await requiredExistingBucket(ctx, "pi-sync-your-name", signal);
 	return bucket ? { ...suggested, bucket } : undefined;
 }
 
 async function chooseAdditionalRemoteLocation(
 	ctx: ExtensionCommandContext,
 	settings: Record<string, unknown>,
-	profileName: string,
-	targetName: string,
-): Promise<Omit<ChosenRemoteLocation, "profileName"> | undefined> {
-	const targets = ownRecord(settings.targets) ?? {};
-	const activeTarget =
-		typeof settings.activeTarget === "string" ? settings.activeTarget : undefined;
-	const candidates = Object.entries(targets)
-		.map(([name, value]) => ({ name, target: ownRecord(value) }))
+	connectionName: string,
+	setupName: string,
+	signal?: AbortSignal,
+): Promise<Omit<ChosenRemoteLocation, "connectionName"> | undefined> {
+	const setups = ownRecord(settings.syncSetups) ?? {};
+	const currentSetup =
+		typeof settings.activeSyncSetup === "string" ? settings.activeSyncSetup : undefined;
+	const candidates = Object.entries(setups)
+		.map(([name, value]) => ({ name, storage: ownRecord(ownRecord(value)?.storage) }))
 		.filter(
-			(item): item is { name: string; target: Record<string, unknown> } =>
-				item.target?.profile === profileName && typeof item.target.bucket === "string",
+			(item): item is { name: string; storage: Record<string, unknown> } =>
+				item.storage?.connection === connectionName && typeof item.storage.bucket === "string",
 		);
 	const source =
-		candidates.find((item) => item.name === activeTarget) ??
+		candidates.find((item) => item.name === currentSetup) ??
 		candidates.sort((left, right) => left.name.localeCompare(right.name))[0];
 	if (source) {
-		const sourcePrefix =
-			typeof source.target.prefix === "string" ? source.target.prefix : "pi-sync";
+		const sourcePath =
+			typeof source.storage.path === "string" ? source.storage.path : "pi-sync/home";
+		const sourceParent = sourcePath.includes("/")
+			? sourcePath.slice(0, sourcePath.lastIndexOf("/"))
+			: "pi-sync";
+		const suggestedPath = `${sourceParent}/${setupName}`;
 		const sameBucketLabel = `Same bucket as “${safeTerminalText(source.name)}” (recommended)`;
 		const choice = await ctx.ui.select(
 			[
-				`Remote location for “${safeTerminalText(targetName)}”`,
+				`Storage location for “${safeTerminalText(setupName)}”`,
 				"",
-				`Recommended bucket: ${safeTerminalText(String(source.target.bucket))}`,
-				`Remote path: ${formatRemotePath(sourcePrefix, targetName)}`,
-				"The namespace and local sync state remain separate.",
+				`Recommended bucket: ${safeTerminalText(String(source.storage.bucket))}`,
+				`Remote path: ${safeTerminalText(suggestedPath)}`,
+				"The complete path and local sync state remain separate.",
 			].join("\n"),
 			[sameBucketLabel, "Use a different bucket", "Customize remote location", "Cancel"],
+			{ signal },
 		);
 		if (!choice || choice === "Cancel") return undefined;
 		if (choice === sameBucketLabel) {
-			return {
-				bucket: String(source.target.bucket),
-				prefix: sourcePrefix,
-				namespace: targetName,
-			};
+			return { bucket: String(source.storage.bucket), path: suggestedPath };
 		}
 		if (choice === "Use a different bucket") {
-			const bucket = await requiredExistingBucket(ctx, "pi-sync");
-			return bucket ? { bucket, prefix: "pi-sync", namespace: targetName } : undefined;
+			const bucket = await requiredExistingBucket(ctx, "pi-sync", signal);
+			return bucket ? { bucket, path: `pi-sync/${setupName}` } : undefined;
 		}
-		const custom = await chooseCustomRemoteLocation(ctx, targetName, profileName, false);
-		return custom
-			? { bucket: custom.bucket, prefix: custom.prefix, namespace: custom.namespace }
-			: undefined;
+		const custom = await chooseCustomRemoteLocation(ctx, setupName, connectionName, false, signal);
+		return custom ? { bucket: custom.bucket, path: custom.path } : undefined;
 	}
 
-	const profileSettings = ownRecord(ownRecord(settings.profiles)?.[profileName]);
-	const isR2 =
-		profileSettings?.kind === "r2" ||
-		isCloudflareR2Endpoint(String(profileSettings?.endpoint ?? ""));
+	const connectionSettings = ownRecord(ownRecord(settings.storageConnections)?.[connectionName]);
+	const isR2 = isCloudflareR2Endpoint(String(connectionSettings?.endpoint ?? ""));
+	const suggestedPath = `pi-sync/${setupName}`;
 	const suggestedLabel = isR2
 		? "Use suggested location (recommended)"
 		: "Use existing bucket with suggested path (recommended)";
 	const choice = await ctx.ui.select(
-		`Remote location for “${safeTerminalText(targetName)}”\n\nSuggested path: ${formatRemotePath("pi-sync", targetName)}`,
+		`Storage location for “${safeTerminalText(setupName)}”\n\nSuggested path: ${safeTerminalText(suggestedPath)}`,
 		[suggestedLabel, "Customize remote location", "Cancel"],
+		{ signal },
 	);
 	if (!choice || choice === "Cancel") return undefined;
 	if (choice === "Customize remote location") {
-		const custom = await chooseCustomRemoteLocation(ctx, targetName, profileName, false);
-		return custom
-			? { bucket: custom.bucket, prefix: custom.prefix, namespace: custom.namespace }
-			: undefined;
-	}
-	if (isR2) return { bucket: "pi-sync", prefix: "pi-sync", namespace: targetName };
-	const bucket = await requiredExistingBucket(ctx, "pi-sync-your-name");
-	return bucket ? { bucket, prefix: "pi-sync", namespace: targetName } : undefined;
+		const custom = await chooseCustomRemoteLocation(ctx, setupName, connectionName, false, signal);
+		return custom ? { bucket: custom.bucket, path: custom.path } : undefined;
+	}
+	if (isR2) return { bucket: "pi-sync", path: suggestedPath };
+	const bucket = await requiredExistingBucket(ctx, "pi-sync-your-name", signal);
+	return bucket ? { bucket, path: suggestedPath } : undefined;
 }
 
 async function chooseCustomRemoteLocation(
 	ctx: ExtensionCommandContext,
-	targetName: string,
-	initialProfileName: string,
-	customizeProfileName: boolean,
+	setupName: string,
+	initialConnectionName: string,
+	customizeConnectionName: boolean,
+	signal?: AbortSignal,
 ): Promise<ChosenRemoteLocation | undefined> {
-	const profileName = customizeProfileName
-		? await requiredInput(ctx, "Storage profile name", initialProfileName)
-		: initialProfileName;
-	if (!profileName) return undefined;
-	const bucket = await requiredExistingBucket(ctx, "pi-sync");
+	const connectionName = customizeConnectionName
+		? await requiredInput(ctx, "Storage connection name", initialConnectionName, signal)
+		: initialConnectionName;
+	if (!connectionName) return undefined;
+	const bucket = await requiredExistingBucket(ctx, "pi-sync", signal);
 	if (!bucket) return undefined;
-	const prefix = await requiredInput(ctx, "Remote prefix", "pi-sync");
-	if (!prefix) return undefined;
-	const namespace = await requiredInput(ctx, "Remote namespace", targetName);
-	return namespace ? { profileName, bucket, prefix, namespace } : undefined;
-}
-
-function formatRemotePath(prefix: string, namespace: string) {
-	return safeTerminalText(`${prefix}/profiles/${namespace}/`);
-}
-
-async function requiredExistingBucket(ctx: ExtensionCommandContext, example: string) {
-	const value = await ctx.ui.input("Existing bucket", `Example: ${example}`);
-	if (value === undefined) return undefined;
-	const normalized = value.trim();
-	if (!normalized) {
-		ctx.ui.notify("Enter the name of an existing R2/S3 bucket, or cancel setup.", "warning");
-		return undefined;
-	}
-	return normalized;
-}
-
-async function requiredInput(ctx: ExtensionCommandContext, title: string, placeholder: string) {
-	const value = await ctx.ui.input(title, placeholder);
-	if (value === undefined) return undefined;
-	const normalized = value.trim() || placeholder;
-	return normalized.includes("<") || normalized.includes(">") ? undefined : normalized;
-}
-
-function storageDescription(
-	kind: string | undefined,
-	endpoint: string | undefined,
-	bucket: string | undefined,
-) {
-	const label =
-		kind === "r2" || isCloudflareR2Endpoint(endpoint) ? "Cloudflare R2" : "S3-compatible";
-	return `${label} · ${safeTerminalText(bucket ?? "bucket missing")}`;
-}
-
-function ownRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value)
-		? (value as Record<string, unknown>)
-		: undefined;
-}
-
-function safeTerminalText(value: string) {
-	// biome-ignore lint/suspicious/noControlCharactersInRegex: Escape untrusted terminal controls.
-	return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, "?");
-}
-
-function errorMessage(error: unknown) {
-	return error instanceof Error ? error.message : String(error);
+	const storagePath = await requiredInput(ctx, "Storage path", `pi-sync/${setupName}`, signal);
+	if (!storagePath) return undefined;
+	return { connectionName, bucket, path: storagePath.replace(/^\/+|\/+$/gu, "") };
 }