@narumitw/pi-sync 0.50.2 → 0.51.0

package/src/sync/sync-queries.ts

@@ -7,11 +7,8 @@ import { snapshotOptionsForContext } from "../snapshot/session-paths.js";
 import { createSnapshot, scanSnapshot } from "../snapshot/snapshot.js";
 import type { SnapshotOptions } from "../snapshot/snapshot-types.js";
 import { inspectLock, isLockGuardHeld, isStaleLock, withLock } from "../state/lock.js";
-import {
-	formatDiff,
-	formatSnapshotOnlyDiff,
-	publicationCapabilityDescription,
-} from "../ui/sync-format.js";
+import { formatDiff, formatSnapshotOnlyDiff, publicationCapabilityDescription } from "../ui/sync-format.js";
+import { setSyncStatus } from "../ui/sync-status.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
 import { formatRemoteSelectionStatus, readRemoteSnapshot } from "./remote-snapshot.js";
 import { throwIfAborted } from "./signals.js";
@@ -19,217 +16,201 @@ import { errorMessage } from "./sync-errors.js";
 import { inspectSync } from "./sync-inspection.js";
 import { rollback } from "./sync-mutations.js";
 
-const STATUS_KEY = "sync";
 const DEFAULT_PROFILE = "default";
 
 export async function status(
-	ctx: ExtensionCommandContext,
-	options: CommandOptions,
-	factory: SyncBackendFactory = createSyncBackend,
+  ctx: ExtensionCommandContext,
+  options: CommandOptions,
+  factory: SyncBackendFactory = createSyncBackend,
 ) {
-	const config = await loadConfig(options.setup);
-	throwIfAborted(options.signal);
-	ctx.ui.setStatus(STATUS_KEY, `checking ${config.setupName}`);
-	const { head, selectionState, localChanged, remoteChanged, localFiles, destination, capability } =
-		await inspectSync(config, snapshotOptionsForContext(ctx, config), options.signal, factory);
-	throwIfAborted(options.signal);
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  setSyncStatus(ctx, `checking ${config.setupName}`);
+  const { head, selectionState, localChanged, remoteChanged, localFiles, destination, capability } = await inspectSync(
+    config,
+    snapshotOptionsForContext(ctx, config),
+    options.signal,
+    factory,
+  );
+  throwIfAborted(options.signal);
 
-	const remoteText = head
-		? `remote: ${head.snapshotId} from ${head.machine} at ${head.createdAt}`
-		: "remote: empty";
-	const warnings = syncSessionsWarnings(config);
-	ctx.ui.setStatus(STATUS_KEY, undefined);
-	ctx.ui.notify(
-		[
-			`sync setup: ${config.setupName}`,
-			`storage connection: ${config.connectionName}`,
-			`storage location: ${safeTerminalText(destination)}`,
-			`publication safety: ${publicationCapabilityDescription(capability)}`,
-			`included content: ${config.include.join(", ") || "none"}`,
-			`sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
-			remoteText,
-			formatRemoteSelectionStatus(selectionState),
-			`local files: ${localFiles}`,
-			`local changed since last sync: ${localChanged ? "yes" : "no"}`,
-			`remote changed since last sync: ${remoteChanged ? "yes" : "no"}`,
-			...warnings,
-		].join("\n"),
-		localChanged || remoteChanged || selectionState?.kind === "different" || warnings.length > 0
-			? "warning"
-			: "info",
-	);
+  const remoteText = head ? `remote: ${head.snapshotId} from ${head.machine} at ${head.createdAt}` : "remote: empty";
+  const warnings = syncSessionsWarnings(config);
+  setSyncStatus(ctx, undefined);
+  ctx.ui.notify(
+    [
+      `sync setup: ${config.setupName}`,
+      `storage connection: ${config.connectionName}`,
+      `storage location: ${safeTerminalText(destination)}`,
+      `publication safety: ${publicationCapabilityDescription(capability)}`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+      remoteText,
+      formatRemoteSelectionStatus(selectionState),
+      `local files: ${localFiles}`,
+      `local changed since last sync: ${localChanged ? "yes" : "no"}`,
+      `remote changed since last sync: ${remoteChanged ? "yes" : "no"}`,
+      ...warnings,
+    ].join("\n"),
+    localChanged || remoteChanged || selectionState?.kind === "different" || warnings.length > 0 ? "warning" : "info",
+  );
 }
 
 export async function diff(
-	ctx: ExtensionCommandContext,
-	options: CommandOptions,
-	factory: SyncBackendFactory = createSyncBackend,
+  ctx: ExtensionCommandContext,
+  options: CommandOptions,
+  factory: SyncBackendFactory = createSyncBackend,
 ) {
-	const config = await loadConfig(options.setup);
-	throwIfAborted(options.signal);
-	ctx.ui.setStatus(STATUS_KEY, `checking ${config.setupName}`);
-	const backend = await factory(config);
-	const local = await createSnapshot(
-		config.snapshotIdentity,
-		snapshotOptionsForContext(ctx, config),
-	);
-	throwIfAborted(options.signal);
-	const { snapshot: remote, selectionState } = await readRemoteSnapshot(
-		backend,
-		config,
-		options.signal,
-		{ allowSelectionDifference: true },
-	);
-	throwIfAborted(options.signal);
-	ctx.ui.setStatus(STATUS_KEY, undefined);
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  setSyncStatus(ctx, `checking ${config.setupName}`);
+  const backend = await factory(config);
+  const local = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  throwIfAborted(options.signal);
+  const { snapshot: remote, selectionState } = await readRemoteSnapshot(backend, config, options.signal, {
+    allowSelectionDifference: true,
+  });
+  throwIfAborted(options.signal);
+  setSyncStatus(ctx, undefined);
 
-	const warnings = syncSessionsWarnings(config);
-	const header = [
-		`sync setup: ${config.setupName}`,
-		`storage connection: ${config.connectionName}`,
-		`storage location: ${safeTerminalText(backend.destination)}`,
-		`included content: ${config.include.join(", ") || "none"}`,
-		`sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
-		formatRemoteSelectionStatus(selectionState),
-		...warnings,
-	].join("\n");
-	const level = warnings.length > 0 || selectionState?.kind === "different" ? "warning" : "info";
-	if (!remote) {
-		ctx.ui.notify(
-			`${header}\n\n${formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local)}`,
-			level,
-		);
-		return;
-	}
+  const warnings = syncSessionsWarnings(config);
+  const header = [
+    `sync setup: ${config.setupName}`,
+    `storage connection: ${config.connectionName}`,
+    `storage location: ${safeTerminalText(backend.destination)}`,
+    `included content: ${config.include.join(", ") || "none"}`,
+    `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+    formatRemoteSelectionStatus(selectionState),
+    ...warnings,
+  ].join("\n");
+  const level = warnings.length > 0 || selectionState?.kind === "different" ? "warning" : "info";
+  if (!remote) {
+    ctx.ui.notify(`${header}\n\n${formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local)}`, level);
+    return;
+  }
 
-	ctx.ui.notify(`${header}\n\n${formatDiff(local, remote)}`, level);
+  ctx.ui.notify(`${header}\n\n${formatDiff(local, remote)}`, level);
 }
 
 export async function doctor(
-	ctx: ExtensionCommandContext,
-	options: CommandOptions,
-	factory: SyncBackendFactory = createSyncBackend,
+  ctx: ExtensionCommandContext,
+  options: CommandOptions,
+  factory: SyncBackendFactory = createSyncBackend,
 ) {
-	const messages: string[] = [];
-	let level: "info" | "warning" = "info";
-	let snapshotOptions: SnapshotOptions = {};
-	let profile = DEFAULT_PROFILE;
-	let backend: SyncBackend | undefined;
-	let backendSummary: string[] = [];
+  const messages: string[] = [];
+  let level: "info" | "warning" = "info";
+  let snapshotOptions: SnapshotOptions = {};
+  let profile = DEFAULT_PROFILE;
+  let backend: SyncBackend | undefined;
+  let backendSummary: string[] = [];
 
-	try {
-		const config = await loadConfig(options.setup);
-		throwIfAborted(options.signal);
-		backend = await factory(config);
-		profile = config.snapshotIdentity;
-		snapshotOptions = snapshotOptionsForContext(ctx, config);
-		messages.push(
-			`config: ok (sync setup ${config.setupName})`,
-			`included content: ${config.include.join(", ") || "none"}`,
-			`sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
-		);
-		backendSummary = [
-			`storage location: ${safeTerminalText(backend.destination)}`,
-			`publication safety: ${publicationCapabilityDescription(backend.capability)}`,
-		];
-		const warnings = syncSessionsWarnings(config);
-		if (warnings.length > 0) {
-			level = "warning";
-			messages.push(...warnings);
-		}
-	} catch (error) {
-		throwIfAborted(options.signal);
-		level = "warning";
-		messages.push(`config: ${errorMessage(error)}`);
-	}
+  try {
+    const config = await loadConfig(options.setup);
+    throwIfAborted(options.signal);
+    backend = await factory(config);
+    profile = config.snapshotIdentity;
+    snapshotOptions = snapshotOptionsForContext(ctx, config);
+    messages.push(
+      `config: ok (sync setup ${config.setupName})`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+    );
+    backendSummary = [
+      `storage location: ${safeTerminalText(backend.destination)}`,
+      `publication safety: ${publicationCapabilityDescription(backend.capability)}`,
+    ];
+    const warnings = syncSessionsWarnings(config);
+    if (warnings.length > 0) {
+      level = "warning";
+      messages.push(...warnings);
+    }
+  } catch (error) {
+    throwIfAborted(options.signal);
+    level = "warning";
+    messages.push(`config: ${errorMessage(error)}`);
+  }
 
-	const local = await createSnapshot(profile, snapshotOptions);
-	throwIfAborted(options.signal);
-	const secrets = scanSnapshot(local);
-	if (secrets.length > 0) {
-		level = "warning";
-		messages.push("secret scan: possible secrets found:");
-		messages.push(...secrets.map((secret) => `- ${secret}`));
-	} else {
-		messages.push(`secret scan: ok (${local.files.length} files checked)`);
-	}
+  const local = await createSnapshot(profile, snapshotOptions);
+  throwIfAborted(options.signal);
+  const secrets = scanSnapshot(local);
+  if (secrets.length > 0) {
+    level = "warning";
+    messages.push("secret scan: possible secrets found:");
+    messages.push(...secrets.map((secret) => `- ${secret}`));
+  } else {
+    messages.push(`secret scan: ok (${local.files.length} files checked)`);
+  }
 
-	const lock = await inspectLock();
-	throwIfAborted(options.signal);
-	if (lock.status === "valid" && isStaleLock(lock.lock)) {
-		level = "warning";
-		messages.push(
-			`lock: stale (pid ${lock.lock.pid}); run /sync unlock --stale after verifying no sync is running`,
-		);
-	} else if (lock.status === "valid") {
-		messages.push(`lock: held by pid ${lock.lock.pid} since ${lock.lock.startedAt}`);
-	} else if (lock.status === "unreadable") {
-		level = "warning";
-		messages.push(
-			"lock: unreadable; use /sync unlock --stale only after verifying no sync is running",
-		);
-	} else if (await isLockGuardHeld()) {
-		throwIfAborted(options.signal);
-		level = "warning";
-		messages.push("lock: guard active while metadata is missing or still being initialized");
-	} else {
-		messages.push("lock: free");
-	}
+  const lock = await inspectLock();
+  throwIfAborted(options.signal);
+  if (lock.status === "valid" && isStaleLock(lock.lock)) {
+    level = "warning";
+    messages.push(`lock: stale (pid ${lock.lock.pid}); run /sync unlock --stale after verifying no sync is running`);
+  } else if (lock.status === "valid") {
+    messages.push(`lock: held by pid ${lock.lock.pid} since ${lock.lock.startedAt}`);
+  } else if (lock.status === "unreadable") {
+    level = "warning";
+    messages.push("lock: unreadable; use /sync unlock --stale only after verifying no sync is running");
+  } else if (await isLockGuardHeld()) {
+    throwIfAborted(options.signal);
+    level = "warning";
+    messages.push("lock: guard active while metadata is missing or still being initialized");
+  } else {
+    messages.push("lock: free");
+  }
 
-	if (backend) {
-		messages.push(...backendSummary);
-		const diagnostics = await backend.diagnose(options.signal);
-		throwIfAborted(options.signal);
-		for (const diagnostic of diagnostics) {
-			messages.push(diagnostic.message);
-			if (diagnostic.level !== "info") level = "warning";
-		}
-	}
-	ctx.ui.notify(messages.join("\n"), level);
+  if (backend) {
+    messages.push(...backendSummary);
+    const diagnostics = await backend.diagnose(options.signal);
+    throwIfAborted(options.signal);
+    for (const diagnostic of diagnostics) {
+      messages.push(diagnostic.message);
+      if (diagnostic.level !== "info") level = "warning";
+    }
+  }
+  ctx.ui.notify(messages.join("\n"), level);
 }
 
 export async function history(
-	ctx: ExtensionCommandContext,
-	options: CommandOptions,
-	factory: SyncBackendFactory = createSyncBackend,
+  ctx: ExtensionCommandContext,
+  options: CommandOptions,
+  factory: SyncBackendFactory = createSyncBackend,
 ) {
-	const config = await loadConfig(options.setup);
-	throwIfAborted(options.signal);
-	const backend = await factory(config);
-	const snapshots = (await backend.listHistory(options.signal)).slice(-20).reverse();
-	throwIfAborted(options.signal);
-	if (snapshots.length === 0) {
-		ctx.ui.notify("No remote pi-sync history found.", "info");
-		return;
-	}
+  const config = await loadConfig(options.setup);
+  throwIfAborted(options.signal);
+  const backend = await factory(config);
+  const snapshots = (await backend.listHistory(options.signal)).slice(-20).reverse();
+  throwIfAborted(options.signal);
+  if (snapshots.length === 0) {
+    ctx.ui.notify("No remote pi-sync history found.", "info");
+    return;
+  }
 
-	const currentSnapshot = snapshots[0]?.snapshotId;
-	if (ctx.mode === "tui") {
-		const labels = snapshots.map(
-			(item, index) =>
-				`${index + 1}. ${item.createdAt} · ${safeTerminalText(item.machine)} · ${item.snapshotId}${item.snapshotId === currentSnapshot ? " (current)" : ""}${item.syncSessions ? " · sessions" : ""}`,
-		);
-		const selected = await ctx.ui.select(
-			`History for sync setup “${safeTerminalText(config.setupName)}”\n\nChoose a snapshot to preview rollback.`,
-			[...labels, "Back"],
-		);
-		if (!selected || selected === "Back") return;
-		throwIfAborted(options.signal);
-		const index = labels.indexOf(selected);
-		const snapshot = snapshots[index];
-		if (!snapshot) return;
-		await withLock("rollback", () =>
-			rollback(ctx, { ...options, args: [snapshot.snapshotRef], yes: false }, factory, {
-				backendIdentity: backend.identity,
-				setup: config.setupName,
-			}),
-		);
-		return;
-	}
-	ctx.ui.notify(
-		snapshots
-			.map((item) => `${item.snapshotRef} ${item.createdAt} ${safeTerminalText(item.machine)}`)
-			.join("\n"),
-		"info",
-	);
+  const currentSnapshot = snapshots[0]?.snapshotId;
+  if (ctx.mode === "tui") {
+    const labels = snapshots.map(
+      (item, index) =>
+        `${index + 1}. ${item.createdAt} · ${safeTerminalText(item.machine)} · ${item.snapshotId}${item.snapshotId === currentSnapshot ? " (current)" : ""}${item.syncSessions ? " · sessions" : ""}`,
+    );
+    const selected = await ctx.ui.select(
+      `History for sync setup “${safeTerminalText(config.setupName)}”\n\nChoose a snapshot to preview rollback.`,
+      [...labels, "Back"],
+    );
+    if (!selected || selected === "Back") return;
+    throwIfAborted(options.signal);
+    const index = labels.indexOf(selected);
+    const snapshot = snapshots[index];
+    if (!snapshot) return;
+    await withLock("rollback", () =>
+      rollback(ctx, { ...options, args: [snapshot.snapshotRef], yes: false }, factory, {
+        backendIdentity: backend.identity,
+        setup: config.setupName,
+      }),
+    );
+    return;
+  }
+  ctx.ui.notify(
+    snapshots.map((item) => `${item.snapshotRef} ${item.createdAt} ${safeTerminalText(item.machine)}`).join("\n"),
+    "info",
+  );
 }

package/src/sync/sync-state.ts

@@ -1,168 +1,142 @@
 import type { RemoteHead } from "../backends/sync-backend.js";
 import { toPosix } from "../paths.js";
 import {
-	canonicalSnapshotPathForConfig,
-	filterSnapshotForConfigPolicy,
-	isConfiguredSnapshotPath,
-	isSessionPath,
+  canonicalSnapshotPathForConfig,
+  filterSnapshotForConfigPolicy,
+  isConfiguredSnapshotPath,
+  isSessionPath,
 } from "../snapshot/snapshot.js";
 import type { Snapshot } from "../snapshot/snapshot-types.js";
 import type { SyncState } from "../state/state-types.js";
 import {
-	customIncludePathsByLower,
-	includeFromSelectionConfig,
-	normalizeSyncInclude,
-	type SyncSelectionConfig,
+  customIncludePathsByLower,
+  includeFromSelectionConfig,
+  normalizeSyncInclude,
+  type SyncSelectionConfig,
 } from "./sync-policy.js";
 
 type SyncPolicyConfig = SyncSelectionConfig;
 
 export function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncPolicyConfig) {
-	return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
+  return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
 }
 
 export function remoteChangedSinceState(
-	head: RemoteHead | undefined,
-	state: SyncState,
-	config: SyncPolicyConfig,
-	sameRevision: (left: string, right: string) => boolean,
+  head: RemoteHead | undefined,
+  state: SyncState,
+  config: SyncPolicyConfig,
+  sameRevision: (left: string, right: string) => boolean,
 ) {
-	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
-	);
+  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: SyncPolicyConfig,
-	ignoredPaths = new Set<string>(),
+  remote: Snapshot,
+  state: SyncState,
+  config: SyncPolicyConfig,
+  ignoredPaths = new Set<string>(),
 ) {
-	if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
-	return !snapshotHashesMatchState(
-		filterSnapshotForConfigPolicy(remote, config),
-		state,
-		config,
-		ignoredPaths,
-	);
+  if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
+  return !snapshotHashesMatchState(filterSnapshotForConfigPolicy(remote, config), state, config, ignoredPaths);
 }
 
 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;
-	return true;
+  const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+  for (const key of keys) if (left[key] !== right[key]) return false;
+  return true;
 }
 
 export function fileHashMap(snapshot: Snapshot) {
-	return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
+  return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
 }
 
 function stateHashMapForConfig(state: SyncState, config: SyncPolicyConfig) {
-	const includePaths = customIncludePathsByLower(includeFromSelectionConfig(config));
-	return Object.fromEntries(
-		Object.entries(state.lastFileHashes)
-			.filter(([filePath]) => isConfiguredSnapshotPath(filePath, config))
-			.map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, includePaths), hash]),
-	);
+  const includePaths = customIncludePathsByLower(includeFromSelectionConfig(config));
+  return Object.fromEntries(
+    Object.entries(state.lastFileHashes)
+      .filter(([filePath]) => isConfiguredSnapshotPath(filePath, config))
+      .map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, includePaths), hash]),
+  );
 }
 
 export function snapshotHashesMatchState(
-	snapshot: Snapshot,
-	state: SyncState,
-	config: SyncPolicyConfig,
-	ignoredPaths = new Set<string>(),
+  snapshot: Snapshot,
+  state: SyncState,
+  config: SyncPolicyConfig,
+  ignoredPaths = new Set<string>(),
 ) {
-	return sameHashes(
-		withoutHashPaths(fileHashMap(snapshot), ignoredPaths),
-		withoutHashPaths(stateHashMapForConfig(state, config), ignoredPaths),
-	);
+  return sameHashes(
+    withoutHashPaths(fileHashMap(snapshot), ignoredPaths),
+    withoutHashPaths(stateHashMapForConfig(state, config), ignoredPaths),
+  );
 }
 
 export function snapshotsMatch(left: Snapshot, right: Snapshot) {
-	return (
-		left.syncSessions === right.syncSessions && sameHashes(fileHashMap(left), fileHashMap(right))
-	);
+  return left.syncSessions === right.syncSessions && sameHashes(fileHashMap(left), fileHashMap(right));
 }
 
 function withoutHashPaths(hashes: Record<string, string>, ignoredPaths: Set<string>) {
-	if (ignoredPaths.size === 0) return hashes;
-	return Object.fromEntries(
-		Object.entries(hashes).filter(([filePath]) => !ignoredPaths.has(toPosix(filePath))),
-	);
+  if (ignoredPaths.size === 0) return hashes;
+  return Object.fromEntries(Object.entries(hashes).filter(([filePath]) => !ignoredPaths.has(toPosix(filePath))));
 }
 
 export function syncPolicyChanged(state: SyncState, config: SyncPolicyConfig) {
-	return syncIncludeChanged(state, config);
+  return syncIncludeChanged(state, config);
 }
 
 export function shouldRefreshSyncedState(
-	remote: Snapshot,
-	head: RemoteHead | undefined,
-	state: SyncState,
-	config: SyncPolicyConfig,
-	sameRevision: (left: string, right: string) => boolean,
+  remote: Snapshot,
+  head: RemoteHead | undefined,
+  state: SyncState,
+  config: SyncPolicyConfig,
+  sameRevision: (left: string, right: string) => boolean,
 ) {
-	return (
-		remote.id !== state.lastAppliedSnapshot ||
-		Boolean(
-			head && (!state.lastRemoteRevision || !sameRevision(head.revision, state.lastRemoteRevision)),
-		) ||
-		syncPolicyChanged(state, config)
-	);
+  return (
+    remote.id !== state.lastAppliedSnapshot ||
+    Boolean(head && (!state.lastRemoteRevision || !sameRevision(head.revision, state.lastRemoteRevision))) ||
+    syncPolicyChanged(state, config)
+  );
 }
 
 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]);
+  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) {
-	return Object.fromEntries(
-		snapshot.files
-			.filter((file) => !isSessionPath(file.path))
-			.map((file) => [file.path, file.sha256]),
-	);
+  return Object.fromEntries(
+    snapshot.files.filter((file) => !isSessionPath(file.path)).map((file) => [file.path, file.sha256]),
+  );
 }
 
 export function sessionHashMap(snapshot: Snapshot) {
-	return Object.fromEntries(
-		snapshot.files
-			.filter((file) => isSessionPath(file.path))
-			.map((file) => [file.path, file.sha256]),
-	);
+  return Object.fromEntries(
+    snapshot.files.filter((file) => isSessionPath(file.path)).map((file) => [file.path, file.sha256]),
+  );
 }
 
 export function settingsHashMapFromState(state: SyncState) {
-	return Object.fromEntries(
-		Object.entries(state.lastFileHashes).filter(([filePath]) => !isSessionPath(filePath)),
-	);
+  return Object.fromEntries(Object.entries(state.lastFileHashes).filter(([filePath]) => !isSessionPath(filePath)));
 }
 
 export function settingsHashesMatchState(remote: Snapshot, state: SyncState) {
-	return sameHashes(settingsHashMap(remote), settingsHashMapFromState(state));
+  return sameHashes(settingsHashMap(remote), settingsHashMapFromState(state));
 }
 
 export function canPullRemoteSettingsOnFirstSync(local: Snapshot, remote: Snapshot) {
-	const remoteSettings = settingsHashMap(remote);
-	return Object.entries(settingsHashMap(local)).every(
-		([filePath, hash]) => remoteSettings[filePath] === hash,
-	);
+  const remoteSettings = settingsHashMap(remote);
+  return Object.entries(settingsHashMap(local)).every(([filePath, hash]) => remoteSettings[filePath] === hash);
 }
 
 export function canPullRemoteSessionsOnFirstSync(local: Snapshot, remote: Snapshot) {
-	const localSessions = sessionHashMap(local);
-	const remoteSessions = sessionHashMap(remote);
-	return Object.entries(localSessions).every(
-		([filePath, hash]) => remoteSessions[filePath] === hash,
-	);
+  const localSessions = sessionHashMap(local);
+  const remoteSessions = sessionHashMap(remote);
+  return Object.entries(localSessions).every(([filePath, hash]) => remoteSessions[filePath] === hash);
 }