@narumitw/pi-sync 0.31.0 → 0.34.0

package/src/sync-policy.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { isDeniedPath, toPosix } from "./paths.js";
 
-export const DEFAULT_SYNC_FILES = [
+export const BUILT_IN_SYNC_ROOTS = [
 	"settings.json",
 	"keybindings.json",
 	"models.json",
@@ -13,100 +13,148 @@ export const DEFAULT_SYNC_FILES = [
 	"extensions",
 ] as const;
 
-export type BuiltInSyncFile = (typeof DEFAULT_SYNC_FILES)[number];
+export const DEFAULT_SYNC_INCLUDE = [...BUILT_IN_SYNC_ROOTS] as const;
+export type BuiltInSyncFile = (typeof BUILT_IN_SYNC_ROOTS)[number];
 
 const BUILT_IN_BY_LOWER = new Map<string, BuiltInSyncFile>(
-	DEFAULT_SYNC_FILES.map((fileName) => [fileName.toLowerCase(), fileName]),
+	BUILT_IN_SYNC_ROOTS.map((fileName) => [fileName.toLowerCase(), fileName]),
 );
 const TOP_LEVEL_FILE_PATHS = new Map<string, string>(
-	DEFAULT_SYNC_FILES.filter((fileName) => fileName.includes(".")).map((fileName) => [
+	BUILT_IN_SYNC_ROOTS.filter((fileName) => fileName.includes(".")).map((fileName) => [
 		fileName.toLowerCase(),
 		fileName,
 	]),
 );
-const TOP_LEVEL_FILE_NAMES = new Set<string>(TOP_LEVEL_FILE_PATHS.keys());
 const TOP_LEVEL_DIRS = new Set<string>(
-	DEFAULT_SYNC_FILES.filter((fileName) => !fileName.includes(".")),
+	BUILT_IN_SYNC_ROOTS.filter((fileName) => !fileName.includes(".")),
 );
 const RESERVED_TOP_LEVEL_NAMES = new Set<string>([...TOP_LEVEL_DIRS, "sessions"]);
 
-export function normalizeSyncFiles(value: unknown): BuiltInSyncFile[] {
-	if (value === undefined) return [...DEFAULT_SYNC_FILES];
-	if (!Array.isArray(value)) throw new Error("syncFiles must be an array of built-in file names.");
-
-	const result: BuiltInSyncFile[] = [];
+export function normalizeSyncInclude(value: unknown): string[] {
+	if (!Array.isArray(value)) {
+		throw new Error("Invalid pi-sync settings: sync.include must be an array.");
+	}
+	const result: string[] = [];
 	const seen = new Set<string>();
 	for (const item of value) {
-		if (typeof item !== "string") throw new Error("syncFiles items must be strings.");
-		const canonical = BUILT_IN_BY_LOWER.get(item.trim().toLowerCase());
-		if (!canonical) throw new Error(`Unknown syncFiles item: ${item}`);
-		const lower = canonical.toLowerCase();
-		if (seen.has(lower)) continue;
-		seen.add(lower);
-		result.push(canonical);
+		if (typeof item !== "string") {
+			throw new Error("Invalid pi-sync settings: sync.include items must be strings.");
+		}
+		const trimmed = item.trim();
+		const builtIn = BUILT_IN_BY_LOWER.get(trimmed.toLowerCase());
+		const normalized = builtIn ?? (trimmed.toLowerCase() === "sessions" ? "sessions" : trimmed);
+		if (!builtIn && normalized !== "sessions") validateAgentRelativeInclude(normalized);
+		const identity = normalized.toLowerCase();
+		if (seen.has(identity)) {
+			throw new Error(`Invalid pi-sync settings: duplicate sync.include item: ${item}`);
+		}
+		for (const previous of seen) {
+			if (identity.startsWith(`${previous}/`) || previous.startsWith(`${identity}/`)) {
+				throw new Error(
+					`Invalid pi-sync settings: overlapping sync.include items are ambiguous: ${item}`,
+				);
+			}
+		}
+		seen.add(identity);
+		result.push(normalized);
 	}
 	return result;
 }
 
-export function normalizeExtraFiles(value: unknown) {
-	if (!Array.isArray(value)) return [];
-	const seen = new Set<string>();
-	return value
-		.filter((item): item is string => typeof item === "string")
-		.map((item) => item.trim())
-		.filter((item) => {
-			const lower = item.toLowerCase();
-			if (
-				item === "" ||
-				item === "." ||
-				item === ".." ||
-				item.includes("/") ||
-				item.includes("\\") ||
-				TOP_LEVEL_FILE_NAMES.has(lower) ||
-				isDeniedPath(item) ||
-				RESERVED_TOP_LEVEL_NAMES.has(lower) ||
-				seen.has(lower)
-			) {
-				return false;
-			}
-			seen.add(lower);
-			return true;
-		});
+function validateAgentRelativeInclude(value: string) {
+	const normalized = toPosix(value);
+	const topLevel = normalized.split("/")[0]?.toLowerCase();
+	if (
+		!normalized ||
+		normalized === "." ||
+		normalized === ".." ||
+		normalized.startsWith("../") ||
+		path.posix.isAbsolute(normalized) ||
+		normalized.includes("\\") ||
+		path.posix.normalize(normalized) !== normalized ||
+		// biome-ignore lint/suspicious/noControlCharactersInRegex: Include paths cannot contain controls.
+		/[\u0000-\u001f\u007f-\u009f]/u.test(normalized)
+	) {
+		throw new Error(
+			`Invalid pi-sync settings: sync.include item must be a safe agent-relative path: ${value}`,
+		);
+	}
+	if (isDeniedPath(normalized)) {
+		throw new Error(`Invalid pi-sync settings: ${value} cannot be synced.`);
+	}
+	if (topLevel && RESERVED_TOP_LEVEL_NAMES.has(topLevel)) {
+		throw new Error(
+			`Invalid pi-sync settings: use the canonical ${topLevel} root instead of a nested sync.include path.`,
+		);
+	}
+}
+
+export function syncIncludeSelection(value: unknown) {
+	const include = normalizeSyncInclude(value);
+	const builtIns = include.filter((item): item is BuiltInSyncFile =>
+		BUILT_IN_BY_LOWER.has(item.toLowerCase()),
+	);
+	const custom = include.filter(
+		(item) => item !== "sessions" && !BUILT_IN_BY_LOWER.has(item.toLowerCase()),
+	);
+	return { include, builtIns, custom, sessions: include.includes("sessions") };
+}
+
+export function customIncludePathsByLower(value: unknown) {
+	return new Map(
+		syncIncludeSelection(value).custom.map((relativePath) => [
+			relativePath.toLowerCase(),
+			relativePath,
+		]),
+	);
 }
 
-export function extraFilePathsByLower(value: unknown) {
-	return new Map(normalizeExtraFiles(value).map((fileName) => [fileName.toLowerCase(), fileName]));
+export interface SyncSelectionConfig {
+	include?: unknown;
+	syncFiles?: unknown;
+	syncSessions?: boolean;
+	extraFiles?: unknown;
 }
 
-export function selectedSyncFileSet(value: unknown) {
-	return new Set(normalizeSyncFiles(value));
+export function includeFromSelectionConfig(config: SyncSelectionConfig) {
+	if (config.include !== undefined) return normalizeSyncInclude(config.include);
+	return [
+		...normalizeSyncFiles(config.syncFiles),
+		...normalizeExtraFiles(config.extraFiles),
+		...(config.syncSessions ? ["sessions"] : []),
+	];
 }
 
 export function isConfiguredSnapshotPath(
 	relativePath: string,
-	config: { syncFiles?: unknown; syncSessions: boolean },
-	extraFiles: Set<string>,
+	config: SyncSelectionConfig,
+	_legacyExtraFiles?: Set<string>,
 ) {
 	const normalized = toPosix(relativePath);
-	if (normalized.startsWith("sessions/")) return config.syncSessions;
-	const selected = selectedSyncFileSet(config.syncFiles);
+	const selection = syncIncludeSelection(includeFromSelectionConfig(config));
+	if (normalized.startsWith("sessions/")) return selection.sessions;
+	const lower = normalized.toLowerCase();
 	if (!normalized.includes("/")) {
-		const lower = normalized.toLowerCase();
 		const builtIn = BUILT_IN_BY_LOWER.get(lower);
-		return builtIn ? selected.has(builtIn) && !TOP_LEVEL_DIRS.has(builtIn) : extraFiles.has(lower);
+		if (builtIn) return selection.builtIns.includes(builtIn) && !TOP_LEVEL_DIRS.has(builtIn);
 	}
 	const topLevel = normalized.slice(0, normalized.indexOf("/"));
-	return selected.has(topLevel as BuiltInSyncFile) && TOP_LEVEL_DIRS.has(topLevel);
+	if (selection.builtIns.includes(topLevel as BuiltInSyncFile) && TOP_LEVEL_DIRS.has(topLevel)) {
+		return true;
+	}
+	return selection.custom.some((candidate) => {
+		const candidateLower = candidate.toLowerCase();
+		return lower === candidateLower || lower.startsWith(`${candidateLower}/`);
+	});
 }
 
 export function canonicalSnapshotPathForConfig(
 	relativePath: string,
-	extraFilePaths: Map<string, string>,
+	includePaths: Map<string, string>,
 ) {
 	const normalized = toPosix(relativePath);
-	if (normalized.includes("/")) return normalized;
 	const lower = normalized.toLowerCase();
-	return TOP_LEVEL_FILE_PATHS.get(lower) ?? extraFilePaths.get(lower) ?? normalized;
+	return TOP_LEVEL_FILE_PATHS.get(lower) ?? includePaths.get(lower) ?? normalized;
 }
 
 export function isPreservableUnmanagedSnapshotPath(relativePath: string) {
@@ -115,15 +163,43 @@ export function isPreservableUnmanagedSnapshotPath(relativePath: string) {
 	if (normalized.startsWith("sessions/")) return normalized.endsWith(".jsonl");
 	if (!normalized.includes("/")) {
 		const lower = normalized.toLowerCase();
-		return TOP_LEVEL_FILE_NAMES.has(lower) || !RESERVED_TOP_LEVEL_NAMES.has(lower);
+		return TOP_LEVEL_FILE_PATHS.has(lower) || !RESERVED_TOP_LEVEL_NAMES.has(lower);
 	}
-	return TOP_LEVEL_DIRS.has(normalized.slice(0, normalized.indexOf("/")));
+	return true;
 }
 
-export function isSafeExtraFileName(fileName: string) {
-	return normalizeExtraFiles([fileName]).length === 1;
+export function isSafeCustomIncludePath(relativePath: string) {
+	try {
+		validateAgentRelativeInclude(relativePath);
+		return true;
+	} catch {
+		return false;
+	}
 }
 
 export function isBuiltInTopLevelFile(fileName: string) {
-	return TOP_LEVEL_FILE_NAMES.has(path.posix.basename(fileName).toLowerCase());
+	return TOP_LEVEL_FILE_PATHS.has(path.posix.basename(fileName).toLowerCase());
+}
+
+/** Compatibility projection for backend-neutral output while callers move to sync.include. */
+export function normalizeSyncFiles(value: unknown): BuiltInSyncFile[] {
+	if (value === undefined) return [...DEFAULT_SYNC_INCLUDE];
+	if (Array.isArray(value)) {
+		return normalizeSyncInclude(value).filter((item): item is BuiltInSyncFile =>
+			BUILT_IN_BY_LOWER.has(item.toLowerCase()),
+		);
+	}
+	throw new Error("Invalid pi-sync settings: expected an include array.");
 }
+
+/** Compatibility projection for old rendering helpers; v3 persistence never writes this split field. */
+export function normalizeExtraFiles(value: unknown) {
+	if (!Array.isArray(value)) return [];
+	return value.filter(
+		(item): item is string => typeof item === "string" && isSafeCustomIncludePath(item),
+	);
+}
+
+export const extraFilePathsByLower = customIncludePathsByLower;
+export const isSafeExtraFileName = isSafeCustomIncludePath;
+export const selectedSyncFileSet = (value: unknown) => new Set(normalizeSyncFiles(value));

package/src/sync-setups-ui.ts

@@ -0,0 +1,177 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig, readLocalConfigObject } from "./config.js";
+import { errorMessage, ownRecord, safeTerminalText } from "./manager-helpers.js";
+import { syncIncludeSelection } from "./sync-policy.js";
+
+const BACK = "Back";
+
+export async function countValidSyncSetups(
+	setups: Record<string, unknown> | undefined,
+	signal?: AbortSignal,
+) {
+	let count = 0;
+	for (const name of Object.keys(setups ?? {})) {
+		throwIfAborted(signal);
+		let valid = false;
+		try {
+			await loadConfig(name);
+			valid = true;
+		} catch {
+			// Invalid setups stay visible in management but are not switchable.
+		}
+		throwIfAborted(signal);
+		if (valid) count += 1;
+	}
+	return count;
+}
+
+function throwIfAborted(signal?: AbortSignal) {
+	if (!signal?.aborted) return;
+	throw signal.reason instanceof Error
+		? signal.reason
+		: new DOMException("The operation was aborted", "AbortError");
+}
+
+type SyncSetupActions = {
+	add(signal?: AbortSignal): Promise<void>;
+	edit(name: string, signal?: AbortSignal): Promise<void>;
+	makeCurrent(name: string, signal?: AbortSignal): Promise<"exit" | undefined>;
+	remove(name: string, signal?: AbortSignal): Promise<void>;
+};
+
+export async function showSyncSetups(
+	ctx: ExtensionCommandContext,
+	actions: SyncSetupActions,
+	signal?: AbortSignal,
+): Promise<"exit" | undefined> {
+	while (!signal?.aborted) {
+		const raw = await readLocalConfigObject();
+		throwIfAborted(signal);
+		const setups = ownRecord(raw?.syncSetups) ?? {};
+		const active = typeof raw?.activeSyncSetup === "string" ? raw.activeSyncSetup : undefined;
+		const labels = new Map<string, string>();
+		for (const name of Object.keys(setups).sort((left, right) => left.localeCompare(right))) {
+			const label = `${safeTerminalText(name)}${name === active ? " (current)" : ""}`;
+			labels.set(label, name);
+		}
+		const selected = await ctx.ui.select(
+			"Sync setups",
+			["Add sync setup", ...labels.keys(), BACK],
+			{ signal },
+		);
+		if (signal?.aborted || !selected || selected === BACK) return;
+		if (selected === "Add sync setup") {
+			try {
+				await actions.add(signal);
+			} catch (error) {
+				if (signal?.aborted) return;
+				ctx.ui.notify(
+					`Sync setup was not added: ${menuErrorMessage(error)} Retry from Add sync setup.`,
+					"error",
+				);
+			}
+			continue;
+		}
+		const name = labels.get(selected);
+		if (!name) continue;
+		const result = await showSyncSetupDetail(ctx, name, actions, signal);
+		if (result === "exit") return "exit";
+	}
+}
+
+async function showSyncSetupDetail(
+	ctx: ExtensionCommandContext,
+	name: string,
+	actions: SyncSetupActions,
+	signal?: AbortSignal,
+): Promise<"exit" | undefined> {
+	while (!signal?.aborted) {
+		const raw = await readLocalConfigObject();
+		throwIfAborted(signal);
+		const setups = ownRecord(raw?.syncSetups) ?? {};
+		const setup = ownRecord(setups[name]);
+		if (!setup) {
+			ctx.ui.notify(`Sync setup “${safeTerminalText(name)}” no longer exists.`, "warning");
+			return;
+		}
+		const active = typeof raw?.activeSyncSetup === "string" ? raw.activeSyncSetup : undefined;
+		const setupCount = Object.keys(setups).length;
+		const isCurrent = name === active;
+		let detail: string[];
+		let valid = true;
+		try {
+			const config = await loadConfig(name);
+			throwIfAborted(signal);
+			const selection = syncIncludeSelection(config.include);
+			detail = [
+				`Status: ${isCurrent ? "Current" : "Not current"}`,
+				`Storage connection: ${safeTerminalText(config.connectionName)}`,
+				`Endpoint: ${storageEndpoint(config)}`,
+				`Storage location: ${storageLocation(config)}`,
+				`Included content: ${selection.builtIns.length} built-in groups · ${selection.custom.length} extra paths`,
+				`Sessions: ${selection.sessions ? "On — privacy-sensitive" : "Off"}`,
+				`Automatic sync: ${config.automatic ? "On" : "Off"}`,
+			];
+		} catch (error) {
+			valid = false;
+			detail = [
+				`Status: Invalid${isCurrent ? " current setup" : ""}`,
+				`Reason: ${menuErrorMessage(error)}`,
+				"Make current and sync are unavailable until this setup is repaired.",
+			];
+		}
+		const removeUnavailable = isCurrent && setupCount > 1;
+		if (removeUnavailable) detail.push("Remove unavailable: switch to another setup first.");
+		const selected = await ctx.ui.select(
+			[`Sync setup “${safeTerminalText(name)}”`, "", ...detail].join("\n"),
+			[
+				...(!isCurrent && valid ? ["Make current…"] : []),
+				"Edit sync setup…",
+				...(removeUnavailable ? [] : ["Remove sync setup…"]),
+				BACK,
+			],
+			{ signal },
+		);
+		if (signal?.aborted || !selected || selected === BACK) return;
+		try {
+			if (selected === "Make current…") return actions.makeCurrent(name, signal);
+			if (selected === "Edit sync setup…") await actions.edit(name, signal);
+			else if (selected === "Remove sync setup…") {
+				await actions.remove(name, signal);
+				return;
+			}
+		} catch (error) {
+			if (signal?.aborted) return;
+			ctx.ui.notify(
+				`Sync setup “${safeTerminalText(name)}” was not changed: ${menuErrorMessage(error)} Reopen it and retry.`,
+				"error",
+			);
+		}
+	}
+}
+
+function menuErrorMessage(error: unknown) {
+	return safeTerminalText(errorMessage(error));
+}
+
+function storageEndpoint(config: Awaited<ReturnType<typeof loadConfig>>) {
+	switch (config.backend.type) {
+		case "s3":
+			return safeTerminalText(config.backend.profile.endpoint);
+		case "git":
+			return safeTerminalText(config.backend.profile.remote);
+		case "webdav":
+			return safeTerminalText(config.backend.profile.url);
+	}
+}
+
+function storageLocation(config: Awaited<ReturnType<typeof loadConfig>>) {
+	switch (config.backend.type) {
+		case "s3":
+			return safeTerminalText(`${config.backend.destination.bucket}/${config.storagePath}`);
+		case "git":
+			return safeTerminalText(`Git · ${config.backend.destination.branch}:${config.storagePath}`);
+		case "webdav":
+			return safeTerminalText(`WebDAV · ${config.storagePath}`);
+	}
+}

package/src/sync-state.ts

@@ -5,28 +5,43 @@ import {
 	isConfiguredSnapshotPath,
 	isSessionPath,
 } from "./snapshot.js";
-import { extraFilePathsByLower, normalizeExtraFiles, normalizeSyncFiles } from "./sync-policy.js";
-import type { LatestPointer, RemoteObject, Snapshot, SyncConfig, SyncState } from "./types.js";
+import type { RemoteHead } from "./sync-backend.js";
+import {
+	customIncludePathsByLower,
+	includeFromSelectionConfig,
+	normalizeSyncInclude,
+	type SyncSelectionConfig,
+} from "./sync-policy.js";
+import type { Snapshot, SyncState } from "./types.js";
+
+type SyncPolicyConfig = SyncSelectionConfig;
 
-export function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncConfig) {
+export function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncPolicyConfig) {
 	return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
 }
 
 export function remoteChangedSinceState(
-	latest: RemoteObject<LatestPointer>,
+	head: RemoteHead | undefined,
 	state: SyncState,
-	config: SyncConfig,
+	config: SyncPolicyConfig,
+	sameRevision: (left: string, right: string) => boolean,
 ) {
-	if (latest.missing) return Boolean(state.lastAppliedSnapshot);
-	if (latest.value?.snapshot !== state.lastAppliedSnapshot) return true;
-	if (syncFilesChanged(state, config) || extraFilesChanged(state, config)) return true;
-	return config.syncSessions && state.syncSessions !== true && latest.value?.syncSessions === true;
+	if (!head) return Boolean(state.lastAppliedSnapshot);
+	if (head.snapshotId !== state.lastAppliedSnapshot) return true;
+	if (state.lastRemoteRevision && !sameRevision(head.revision, state.lastRemoteRevision))
+		return true;
+	if (syncIncludeChanged(state, config)) return true;
+	return (
+		includeFromSelectionConfig(config).includes("sessions") &&
+		!state.include?.includes("sessions") &&
+		head.syncSessions
+	);
 }
 
 export function hasRemoteChanges(
 	remote: Snapshot,
 	state: SyncState,
-	config: SyncConfig,
+	config: SyncPolicyConfig,
 	ignoredPaths = new Set<string>(),
 ) {
 	if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
@@ -40,9 +55,7 @@ export function hasRemoteChanges(
 
 export function sameHashes(left: Record<string, string>, right: Record<string, string>) {
 	const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
-	for (const key of keys) {
-		if (left[key] !== right[key]) return false;
-	}
+	for (const key of keys) if (left[key] !== right[key]) return false;
 	return true;
 }
 
@@ -50,23 +63,19 @@ export function fileHashMap(snapshot: Snapshot) {
 	return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
 }
 
-function stateHashMapForConfig(
-	state: SyncState,
-	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
-) {
-	const extraFilePaths = extraFilePathsByLower(config.extraFiles);
-	const extraFiles = new Set(extraFilePaths.keys());
+function stateHashMapForConfig(state: SyncState, config: SyncPolicyConfig) {
+	const includePaths = customIncludePathsByLower(includeFromSelectionConfig(config));
 	return Object.fromEntries(
 		Object.entries(state.lastFileHashes)
-			.filter(([filePath]) => isConfiguredSnapshotPath(filePath, config, extraFiles))
-			.map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, extraFilePaths), hash]),
+			.filter(([filePath]) => isConfiguredSnapshotPath(filePath, config))
+			.map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, includePaths), hash]),
 	);
 }
 
 export function snapshotHashesMatchState(
 	snapshot: Snapshot,
 	state: SyncState,
-	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+	config: SyncPolicyConfig,
 	ignoredPaths = new Set<string>(),
 ) {
 	return sameHashes(
@@ -88,41 +97,32 @@ function withoutHashPaths(hashes: Record<string, string>, ignoredPaths: Set<stri
 	);
 }
 
-export function syncPolicyChanged(
-	state: SyncState,
-	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
-) {
-	return (
-		syncFilesChanged(state, config) ||
-		(state.syncSessions ?? false) !== config.syncSessions ||
-		extraFilesChanged(state, config)
-	);
+export function syncPolicyChanged(state: SyncState, config: SyncPolicyConfig) {
+	return syncIncludeChanged(state, config);
 }
 
 export function shouldRefreshSyncedState(
 	remote: Snapshot,
+	head: RemoteHead | undefined,
 	state: SyncState,
-	config: Pick<SyncConfig, "syncFiles" | "syncSessions" | "extraFiles">,
+	config: SyncPolicyConfig,
+	sameRevision: (left: string, right: string) => boolean,
 ) {
-	return remote.id !== state.lastAppliedSnapshot || syncPolicyChanged(state, config);
-}
-
-function syncFilesChanged(state: SyncState, config: Pick<SyncConfig, "syncFiles">) {
-	return !sameStringSet(normalizeSyncFiles(state.syncFiles), normalizeSyncFiles(config.syncFiles));
-}
-
-function extraFilesChanged(state: SyncState, config: Pick<SyncConfig, "extraFiles">) {
-	return !sameStringSet(
-		normalizeExtraFiles(state.extraFiles),
-		normalizeExtraFiles(config.extraFiles),
+	return (
+		remote.id !== state.lastAppliedSnapshot ||
+		Boolean(
+			head && (!state.lastRemoteRevision || !sameRevision(head.revision, state.lastRemoteRevision)),
+		) ||
+		syncPolicyChanged(state, config)
 	);
 }
 
-function sameStringSet(left: string[], right: string[]) {
-	const leftSet = new Set(left);
-	const rightSet = new Set(right);
-	if (leftSet.size !== rightSet.size) return false;
-	return [...leftSet].every((item) => rightSet.has(item));
+function syncIncludeChanged(state: SyncState, config: SyncPolicyConfig) {
+	const stored = state.include
+		? normalizeSyncInclude(state.include)
+		: includeFromSelectionConfig(state);
+	const current = includeFromSelectionConfig(config);
+	return stored.length !== current.length || stored.some((item, index) => item !== current[index]);
 }
 
 export function settingsHashMap(snapshot: Snapshot) {