@narumitw/pi-sync 0.25.0 → 0.29.0

package/src/sync.ts

@@ -1,35 +1,45 @@
-import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
-import { gunzip, gzip } from "node:zlib";
 import { promisify } from "node:util";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { completeSyncArguments, parseOptions, splitArgs, usage } from "./command.js";
+import { gunzip, gzip } from "node:zlib";
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+	completeSyncArguments,
+	parseOptions,
+	resolveSyncCommand,
+	setSyncTargetCompletions,
+	usage,
+	validateCommandOptions,
+} from "./command.js";
 import {
-	agentDir,
+	configuredTargetNames,
+	deprecatedPiSyncEnvironmentWarnings,
 	ensureStateDir,
-	extraFilePathsByLower,
+	isEnabled,
+	isExplicitlyEnabled,
 	isMissingConfigError,
+	loadConfig,
 	loadPartialConfig,
 	localConfigPath,
+	localConfigTemplate,
 	normalizeExtraFiles,
-	stateDir,
-	writeJson,
-	configuredSessionDir,
-	isCloudflareR2Endpoint,
-	isEnabled,
-	isExplicitlyEnabled,
-	loadConfig,
-	readState,
+	normalizeSyncFiles,
+	readStateForConfig,
 	sessionDirForApply,
 	sessionTokenWarnings,
+	stateDir,
 	syncSessionsWarnings,
-	writeState,
+	writeLocalConfigObject,
+	writeStateForConfig,
 } from "./config.js";
+import { showFileSelection } from "./file-selection.js";
 import { inspectLock, isLockGuardHeld, isStaleLock, unlock, withLock } from "./lock.js";
-import { encodeKey, posixJoin, safeJoin, safeName, toPosix } from "./paths.js";
+import { showSetupWizard, showSyncManager, useSyncTarget } from "./manager-ui.js";
 import {
 	historyKey,
 	latestKey,
@@ -39,27 +49,43 @@ import {
 	snapshotKey,
 } from "./s3-client.js";
 import {
-	addTopLevelCaseVariantDeletes,
-	appliedFileHashMap,
-	applySnapshot,
-	preflightSnapshotApply,
-	protectSnapshotApplyPlan,
-} from "./snapshot-apply.js";
-import {
-	collectFiles,
 	createSnapshot,
-	canonicalSnapshotPathForConfig,
 	filterSnapshotForConfigPolicy,
-	isConfiguredSnapshotPath,
-	isDeniedPath,
-	isSessionPath,
-	sessionSnapshotPathFromAbsolute,
 	mergeRemotePreservedFiles,
-	mergeRemoteSessionFiles,
 	scanSnapshot,
+	sessionSnapshotPathFromAbsolute,
 	snapshotIncludesSessions,
 	snapshotWithoutSessions,
 } from "./snapshot.js";
+import { applySnapshot } from "./snapshot-apply.js";
+import { recoverPendingSnapshotTransactions } from "./snapshot-transaction.js";
+import {
+	countPreservedRemoteFiles,
+	errorMessage,
+	formatDestination,
+	formatDiff,
+	formatPullSummary,
+	formatPushSummary,
+	formatRollbackSummary,
+	formatSnapshotOnlyDiff,
+	redact,
+	remoteIdentity,
+	safeTerminalText,
+	sha256,
+} from "./sync-format.js";
+import {
+	canPullRemoteSessionsOnFirstSync,
+	canPullRemoteSettingsOnFirstSync,
+	fileHashMap,
+	hasLocalChanges,
+	hasRemoteChanges,
+	remoteChangedSinceState,
+	sameHashes,
+	shouldRefreshSyncedState,
+	snapshotHashesMatchState,
+	snapshotsMatch,
+	syncPolicyChanged,
+} from "./sync-state.js";
 import type {
 	CommandOptions,
 	LatestPointer,
@@ -73,12 +99,11 @@ import type {
 const gzipAsync = promisify(gzip);
 const gunzipAsync = promisify(gunzip);
 
-const STATUS_KEY = "pisync";
+const STATUS_KEY = "sync";
 const VERSION = 1;
 const DEFAULT_PROFILE = "default";
 const DEFAULT_PREFIX = "pi-sync";
 const DEFAULT_REGION = "auto";
-const LOCK_STALE_MS = 30 * 60 * 1000;
 
 interface PushInput {
 	config: SyncConfig;
@@ -97,7 +122,7 @@ const AUTO_SYNC_OPTIONS: CommandOptions = {
 	args: [],
 };
 export default function sync(pi: ExtensionAPI) {
-	pi.registerCommand("pisync", {
+	pi.registerCommand("sync", {
 		description: "Sync Pi settings through Cloudflare R2 or S3-compatible storage",
 		getArgumentCompletions: completeSyncArguments,
 		handler: async (args, ctx) => {
@@ -107,41 +132,84 @@ export default function sync(pi: ExtensionAPI) {
 
 	pi.on("session_start", async (_event, ctx) => {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
+		try {
+			await recoverPendingSnapshotTransactions();
+		} catch (error) {
+			ctx.ui.notify(`pi-sync recovery required: ${errorMessage(error)}`, "error");
+			return;
+		}
+		try {
+			setSyncTargetCompletions(await configuredTargetNames());
+		} catch {
+			setSyncTargetCompletions([]);
+		}
+		const warnings = deprecatedPiSyncEnvironmentWarnings();
+		if (warnings.length > 0) ctx.ui.notify(warnings.join("\n"), "warning");
 		await autoSync(ctx);
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {
-		const reason = typeof event === "object" && event ? (event as { reason?: string }).reason : undefined;
+		const reason =
+			typeof event === "object" && event ? (event as { reason?: string }).reason : undefined;
 		if (reason !== "reload") await autoPushSessions(ctx);
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 }
 
 async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext) {
-	const [subcommand = "status", ...rest] = splitArgs(rawArgs);
-	const options = parseOptions(rest);
+	if (!rawArgs.trim()) {
+		try {
+			await showSyncManager(ctx, (route, signal, onCommit) =>
+				executeCommand(route, ctx, signal, onCommit),
+			);
+		} catch (error) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.notify(errorMessage(error), "error");
+		}
+		return;
+	}
+	await executeCommand(rawArgs, ctx);
+}
 
+async function executeCommand(
+	rawArgs: string,
+	ctx: ExtensionCommandContext,
+	signal?: AbortSignal,
+	onCommit?: () => void,
+) {
 	try {
-		await ensureStateDir();
+		const command = await resolveSyncCommand(rawArgs, ctx);
+		if (!command) return;
+		const { subcommand, rest } = command;
+		const options = parseOptions(rest);
+		if (signal) options.signal = signal;
+		if (onCommit) options.onCommit = onCommit;
+		validateCommandOptions(subcommand, options);
 
 		switch (subcommand) {
 			case "help":
 				ctx.ui.notify(usage(), "info");
 				return;
+			case "use":
+				await useSyncTarget(ctx, options.args[0] ?? "");
+				return;
 			case "init":
 				await initConfig(ctx);
 				return;
 			case "config":
-				await showConfig(ctx);
+				await showConfig(ctx, options);
+				return;
+			case "files":
+				await showFileSelection(ctx, options.target);
 				return;
 			case "status":
-				await status(ctx);
+				await status(ctx, options);
 				return;
 			case "diff":
-				await diff(ctx);
+				await diff(ctx, options);
 				return;
 			case "doctor":
-				await doctor(ctx);
+				await doctor(ctx, options);
 				return;
 			case "push":
 				await withLock("push", () => push(ctx, options));
@@ -153,7 +221,7 @@ async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext) {
 				await withLock("sync", () => syncBoth(ctx, options));
 				return;
 			case "history":
-				await history(ctx);
+				await history(ctx, options);
 				return;
 			case "rollback":
 				await withLock("rollback", () => rollback(ctx, options));
@@ -162,10 +230,11 @@ async function handleCommand(rawArgs: string, ctx: ExtensionCommandContext) {
 				await unlock(ctx, options);
 				return;
 			default:
-				ctx.ui.notify(`Unknown /pisync command: ${subcommand}\n\n${usage()}`, "warning");
+				ctx.ui.notify(`Unknown /sync command: ${subcommand}\n\n${usage()}`, "warning");
 		}
 	} catch (error) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
+		if (signal?.aborted && error instanceof Error && error.name === "AbortError") return;
 		ctx.ui.notify(errorMessage(error), "error");
 	}
 }
@@ -193,7 +262,7 @@ async function autoPushSessions(ctx: ExtensionContext) {
 		const config = await loadConfig();
 		if (!config.syncSessions) return;
 		await withLock("auto-session-push", async () => {
-			const state = await readState(config.profile);
+			const state = await readStateForConfig(config);
 			const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
 			if (!hasLocalChanges(local, state, config)) return;
 			await push(ctx, AUTO_SYNC_OPTIONS, { config, state, local });
@@ -212,32 +281,30 @@ async function initConfig(ctx: ExtensionCommandContext) {
 		ctx.ui.notify(`Config already exists: ${configPath}`, "info");
 		return;
 	} catch {
-		// Create below.
-	}
-
-	const sample = {
-		endpoint: "https://<account-id>.r2.cloudflarestorage.com",
-		bucket: "pi-sync",
-		region: DEFAULT_REGION,
-		accessKeyId: "<access-key-id>",
-		secretAccessKey: "<secret-access-key>",
-		profile: DEFAULT_PROFILE,
-		prefix: DEFAULT_PREFIX,
-		autoSync: true,
-		syncSessions: false,
-		extraFiles: [],
-	};
-	await writeJson(configPath, sample);
-	ctx.ui.notify(`Created ${configPath}. Fill in R2 credentials, then run /pisync doctor.`, "info");
+		// Create or guide setup below.
+	}
+
+	if (ctx.mode === "tui") {
+		await showSetupWizard(ctx);
+		return;
+	}
+	await writeLocalConfigObject(localConfigTemplate());
+	ctx.ui.notify(`Created ${configPath}. Fill in R2 credentials, then run /sync doctor.`, "info");
 }
 
-async function showConfig(ctx: ExtensionCommandContext) {
-	const partial = await loadPartialConfig();
+async function showConfig(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const partial = await loadPartialConfig(options.target);
 	const syncSessions = isExplicitlyEnabled(partial.syncSessions);
-	const warnings = [...sessionTokenWarnings(partial), ...syncSessionsWarnings({ syncSessions })];
+	const warnings = [
+		...deprecatedPiSyncEnvironmentWarnings(),
+		...sessionTokenWarnings(partial),
+		...syncSessionsWarnings({ syncSessions }),
+	];
 	ctx.ui.notify(
 		[
 			"pi-sync config:",
+			`target: ${partial.target ?? "default"}`,
+			`storage profile: ${partial.storageProfile ?? "default"}`,
 			`endpoint: ${partial.endpoint ?? "missing"}`,
 			`bucket: ${partial.bucket ?? "missing"}`,
 			`region: ${partial.region ?? DEFAULT_REGION}`,
@@ -247,6 +314,7 @@ async function showConfig(ctx: ExtensionCommandContext) {
 			`profile: ${partial.profile ?? DEFAULT_PROFILE}`,
 			`prefix: ${partial.prefix ?? DEFAULT_PREFIX}`,
 			`autoSync: ${isEnabled(partial.autoSync ?? process.env.PI_SYNC_AUTO_SYNC, true) ? "enabled" : "disabled"}`,
+			`syncFiles: ${normalizeSyncFiles(partial.syncFiles).join(", ") || "none"}`,
 			`syncSessions: ${syncSessions ? "enabled" : "disabled"}`,
 			`extraFiles: ${normalizeExtraFiles(partial.extraFiles).join(", ") || "none"}`,
 			`local config: ${localConfigPath()}`,
@@ -256,26 +324,31 @@ async function showConfig(ctx: ExtensionCommandContext) {
 	);
 }
 
-async function status(ctx: ExtensionCommandContext) {
-	ctx.ui.setStatus(STATUS_KEY, "checking");
-	const config = await loadConfig();
-	const client = new S3Client(config);
+async function status(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const config = await loadConfig(options.target);
+	ctx.ui.setStatus(STATUS_KEY, `checking ${config.target ?? "default"}`);
+	const client = new S3Client(config, options.signal);
 	const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
-	const state = await readState(config.profile);
+	const state = await readStateForConfig(config);
 	const latest = await client.getJson<LatestPointer>(latestKey(config));
 	const localChanged = hasLocalChanges(local, state, config);
 
 	let remoteText = "remote: empty";
-	let remoteChanged = remoteChangedSinceState(latest, state, config);
+	const remoteChanged = remoteChangedSinceState(latest, state, config);
 	if (!latest.missing && latest.value) {
 		remoteText = `remote: ${latest.value.snapshot} from ${latest.value.machine} at ${latest.value.createdAt}`;
 	}
 
-	const warnings = syncSessionsWarnings(config);
+	const warnings = [...deprecatedPiSyncEnvironmentWarnings(), ...syncSessionsWarnings(config)];
 	ctx.ui.setStatus(STATUS_KEY, undefined);
 	ctx.ui.notify(
 		[
-			`profile: ${config.profile}`,
+			`target: ${config.target ?? "default"}`,
+			`storage profile: ${config.storageProfile ?? "default"}`,
+			`destination: ${formatDestination(config)}`,
+			`remote namespace: ${config.profile}`,
+			`sync files: ${normalizeSyncFiles(config.syncFiles).join(", ") || "none"}`,
+			`extra files: ${config.extraFiles.join(", ") || "none"}`,
 			`sessions: ${config.syncSessions ? "included" : "excluded"}`,
 			remoteText,
 			`local files: ${local.files.length}`,
@@ -287,18 +360,24 @@ async function status(ctx: ExtensionCommandContext) {
 	);
 }
 
-async function diff(ctx: ExtensionCommandContext) {
-	ctx.ui.setStatus(STATUS_KEY, "diff");
-	const config = await loadConfig();
-	const client = new S3Client(config);
+async function diff(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const config = await loadConfig(options.target);
+	ctx.ui.setStatus(STATUS_KEY, `checking ${config.target ?? "default"}`);
+	const client = new S3Client(config, options.signal);
 	const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
 	const remote = await readRemoteSnapshot(client, config);
 	ctx.ui.setStatus(STATUS_KEY, undefined);
 
-	const warnings = syncSessionsWarnings(config);
-	const header = [`sessions: ${config.syncSessions ? "included" : "excluded"}`, ...warnings].join(
-		"\n",
-	);
+	const warnings = [...deprecatedPiSyncEnvironmentWarnings(), ...syncSessionsWarnings(config)];
+	const header = [
+		`target: ${config.target ?? "default"}`,
+		`storage profile: ${config.storageProfile ?? "default"}`,
+		`destination: ${formatDestination(config)}`,
+		`sync files: ${normalizeSyncFiles(config.syncFiles).join(", ") || "none"}`,
+		`extra files: ${config.extraFiles.join(", ") || "none"}`,
+		`sessions: ${config.syncSessions ? "included" : "excluded"}`,
+		...warnings,
+	].join("\n");
 	const level = warnings.length > 0 ? "warning" : "info";
 	if (!remote) {
 		ctx.ui.notify(
@@ -311,19 +390,27 @@ async function diff(ctx: ExtensionCommandContext) {
 	ctx.ui.notify(`${header}\n\n${formatDiff(local, remote)}`, level);
 }
 
-async function doctor(ctx: ExtensionCommandContext) {
+async function doctor(ctx: ExtensionCommandContext, options: CommandOptions) {
 	const messages: string[] = [];
 	let level: "info" | "warning" = "info";
 	let snapshotOptions: SnapshotOptions = {};
 	let profile = DEFAULT_PROFILE;
 
 	try {
-		const config = await loadConfig();
+		const config = await loadConfig(options.target);
 		profile = config.profile;
 		snapshotOptions = snapshotOptionsForContext(ctx, config);
-		messages.push(`config: ok (${config.bucket}/${profilePrefix(config)})`);
+		messages.push(
+			`config: ok (target ${config.target ?? "default"}; ${config.bucket}/${profilePrefix(config)})`,
+		);
+		messages.push(`sync files: ${normalizeSyncFiles(config.syncFiles).join(", ") || "none"}`);
+		messages.push(`extra files: ${config.extraFiles.join(", ") || "none"}`);
 		messages.push(`sessions: ${config.syncSessions ? "included" : "excluded"}`);
-		const warnings = [...sessionTokenWarnings(config), ...syncSessionsWarnings(config)];
+		const warnings = [
+			...deprecatedPiSyncEnvironmentWarnings(),
+			...sessionTokenWarnings(config),
+			...syncSessionsWarnings(config),
+		];
 		if (warnings.length > 0) {
 			level = "warning";
 			messages.push(...warnings);
@@ -347,14 +434,14 @@ async function doctor(ctx: ExtensionCommandContext) {
 	if (lock.status === "valid" && isStaleLock(lock.lock)) {
 		level = "warning";
 		messages.push(
-			`lock: stale (pid ${lock.lock.pid}); run /pisync unlock after verifying no sync is running`,
+			`lock: stale (pid ${lock.lock.pid}); run /sync unlock 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 /pisync unlock --stale only after verifying no sync is running",
+			"lock: unreadable; use /sync unlock --stale only after verifying no sync is running",
 		);
 	} else if (await isLockGuardHeld()) {
 		level = "warning";
@@ -370,33 +457,32 @@ async function push(
 	options: CommandOptions,
 	input?: PushInput,
 ) {
-	ctx.ui.setStatus(STATUS_KEY, "pushing");
-	const config = input?.config ?? (await loadConfig());
-	const client = input?.client ?? new S3Client(config);
-	const state = input?.state ?? (await readState(config.profile));
-	const local = input?.local ?? (await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config)));
+	const config = input?.config ?? (await loadConfig(options.target));
+	ctx.ui.setStatus(STATUS_KEY, `pushing ${config.target ?? "default"}`);
+	const client = input?.client ?? new S3Client(config, options.signal);
+	const state = input?.state ?? (await readStateForConfig(config));
+	const local =
+		input?.local ?? (await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config)));
 
 	const latest = await client.getJson<LatestPointer>(latestKey(config));
-	const remoteForUpload = options.force
-		? undefined
-		: await readRemoteSnapshotForUpload(client, config, latest, state);
+	const remoteForUpload = await readRemoteSnapshotForUpload(client, config, latest, state);
 	if (remoteChangedSinceState(latest, state, config) && !options.force) {
 		const remoteForConflict = remoteForUpload
 			? filterSnapshotForConfigPolicy(remoteForUpload, config)
 			: undefined;
 		if (!remoteForConflict || !snapshotHashesMatchState(remoteForConflict, state, config)) {
 			throw new Error(
-				"Remote or sync policy changed since last sync. Run /pisync pull first or /pisync push --force.",
+				"Remote or sync policy changed since last sync. Run /sync pull first or /sync push --force.",
 			);
 		}
 	}
 
-	const upload = await snapshotForUpload(client, config, local, latest, remoteForUpload, {
-		preserveRemote: !options.force,
-	});
+	const upload = await snapshotForUpload(client, config, local, latest, remoteForUpload);
 	const secrets = scanSnapshot(local);
 	if (secrets.length > 0) {
-		throw new Error(`Refusing to push possible secrets:\n${secrets.map((s) => `- ${s}`).join("\n")}`);
+		throw new Error(
+			`Refusing to push possible secrets:\n${secrets.map((s) => `- ${s}`).join("\n")}`,
+		);
 	}
 
 	const preservedRemoteFileCount = countPreservedRemoteFiles(local, upload);
@@ -404,7 +490,7 @@ async function push(
 		!options.yes &&
 		!(await ctx.ui.confirm(
 			snapshotIncludesSessions(upload) ? "Push pi settings and sessions?" : "Push pi settings?",
-			formatPushSummary(upload, latest, preservedRemoteFileCount),
+			formatPushSummary(config, upload, latest, preservedRemoteFileCount, remoteForUpload),
 		))
 	) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
@@ -412,43 +498,56 @@ async function push(
 		return;
 	}
 
-	const pointer = await uploadSnapshot(client, config, upload, latest, options.force);
-	await updateHistory(client, config, pointer);
-	await writeState(config.profile, {
+	options.onCommit?.();
+	const publicationClient = options.onCommit ? new S3Client(config) : client;
+	const pointer = await uploadSnapshot(publicationClient, config, upload, latest, options.force);
+	const historyWarning = await updateHistorySafely(publicationClient, config, pointer);
+	await writeStateForConfig(config, {
 		version: VERSION,
 		profile: config.profile,
 		lastAppliedSnapshot: pointer.snapshot,
 		lastRemoteEtag: undefined,
 		lastFileHashes: fileHashMap(local),
+		syncFiles: config.syncFiles,
 		syncSessions: config.syncSessions,
 		extraFiles: config.extraFiles,
 	});
 	ctx.ui.setStatus(STATUS_KEY, undefined);
 	if (!options.silent) {
-		ctx.ui.notify(`Pushed ${upload.files.length} files as ${pointer.snapshot}.`, "info");
+		ctx.ui.notify(
+			[
+				`Pushed ${upload.files.length} files from target “${config.target ?? "default"}” as ${pointer.snapshot}.`,
+				historyWarning,
+			]
+				.filter(Boolean)
+				.join("\n"),
+			historyWarning ? "warning" : "info",
+		);
 	}
 }
 
 async function pull(ctx: ExtensionCommandContext | ExtensionContext, options: CommandOptions) {
-	ctx.ui.setStatus(STATUS_KEY, "pulling");
-	const config = await loadConfig();
-	const client = new S3Client(config);
-	const state = await readState(config.profile);
+	const config = await loadConfig(options.target);
+	ctx.ui.setStatus(STATUS_KEY, `pulling ${config.target ?? "default"}`);
+	const client = new S3Client(config, options.signal);
+	const state = await readStateForConfig(config);
 	const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
 	const remote = await readRemoteSnapshot(client, config);
-	if (!remote) throw new Error("Remote is empty. Run /pisync push from a configured machine first.");
+	if (!remote) throw new Error("Remote is empty. Run /sync push from a configured machine first.");
 
 	const localChanged = hasLocalChanges(local, state, config);
 	const remoteChanged = hasRemoteChanges(remote, state, config, protectedSessionPaths(ctx));
 	if (localChanged && remoteChanged && state.lastAppliedSnapshot && !options.force) {
-		throw new Error("Both local and remote changed since last sync. Run /pisync diff, then choose /pisync pull --force or /pisync push --force.");
+		throw new Error(
+			"Both local and remote changed since last sync. Run /sync diff, then choose /sync pull --force or /sync push --force.",
+		);
 	}
 
 	if (
 		!options.yes &&
 		!(await ctx.ui.confirm(
 			snapshotIncludesSessions(remote) ? "Pull pi settings and sessions?" : "Pull pi settings?",
-			formatDiff(local, remote),
+			formatPullSummary(config, local, remote, protectedSessionPaths(ctx).size),
 		))
 	) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
@@ -456,24 +555,30 @@ async function pull(ctx: ExtensionCommandContext | ExtensionContext, options: Co
 		return;
 	}
 
+	options.onCommit?.();
 	const backup = await backupLocal(config.profile, snapshotOptionsForContext(ctx, config));
 	const applySessionDir = await sessionDirForApply(ctx, remote);
 	const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+		syncFiles: config.syncFiles,
 		sessionDir: applySessionDir,
 		extraFiles: config.extraFiles,
 	});
-	await writeState(config.profile, {
+	await writeStateForConfig(config, {
 		version: VERSION,
 		profile: config.profile,
 		lastAppliedSnapshot: remote.id,
 		lastRemoteEtag: undefined,
 		lastFileHashes,
+		syncFiles: config.syncFiles,
 		syncSessions: config.syncSessions,
 		extraFiles: config.extraFiles,
 	});
 	ctx.ui.setStatus(STATUS_KEY, undefined);
 	if (!options.silent) {
-		ctx.ui.notify(`Pulled ${remote.files.length} files from ${remote.id}. Backup: ${backup}`, "info");
+		ctx.ui.notify(
+			`Pulled ${remote.files.length} files from ${remote.id}. Backup: ${backup}`,
+			"info",
+		);
 	} else if (options.auto && config.syncSessions && snapshotIncludesSessions(remote)) {
 		ctx.ui.notify(
 			"Pulled Pi sessions after startup selected the current session. Restart Pi or resume a pulled session to use newly synced conversations.",
@@ -484,10 +589,23 @@ async function pull(ctx: ExtensionCommandContext | ExtensionContext, options: Co
 }
 
 async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options: CommandOptions) {
-	const config = await loadConfig();
-	const client = new S3Client(config);
-	const state = await readState(config.profile);
+	const config = await loadConfig(options.target);
+	const client = new S3Client(config, options.signal);
+	const state = await readStateForConfig(config);
 	const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
+	if (
+		normalizeSyncFiles(config.syncFiles).length === 0 &&
+		config.extraFiles.length === 0 &&
+		!config.syncSessions
+	) {
+		if (!options.silent) {
+			ctx.ui.notify(
+				`Target “${config.target ?? "default"}” manages no files. Choose synced content in /sync Settings before syncing.`,
+				"warning",
+			);
+		}
+		return;
+	}
 	const remote = await readRemoteSnapshot(client, config);
 	const localChanged = hasLocalChanges(local, state, config);
 	const remoteChanged = remote
@@ -497,34 +615,41 @@ async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options
 
 	if (firstSync && remote && remote.files.length > 0 && local.files.length > 0) {
 		if (!canPullRemoteSettingsOnFirstSync(local, remote)) {
-			throw new Error("Remote settings exist and this machine has different local Pi settings. Run /pisync diff, then manually choose /pisync pull or /pisync push.");
+			throw new Error(
+				"Remote settings exist and this machine has different local Pi settings. Run /sync diff, then manually choose /sync pull or /sync push.",
+			);
 		}
 		if (!sameHashes(fileHashMap(local), fileHashMap(remote))) {
 			if (!canPullRemoteSessionsOnFirstSync(local, remote)) {
-				throw new Error("Remote settings match, but local and remote Pi sessions differ. Run /pisync diff, then manually choose /pisync pull or /pisync push.");
+				throw new Error(
+					"Remote settings match, but local and remote Pi sessions differ. Run /sync diff, then manually choose /sync pull or /sync push.",
+				);
 			}
 			await pull(ctx, options);
 			return;
 		}
-		await writeState(config.profile, {
+		await writeStateForConfig(config, {
 			version: VERSION,
 			profile: config.profile,
 			lastAppliedSnapshot: remote.id,
 			lastRemoteEtag: undefined,
 			lastFileHashes: fileHashMap(remote),
+			syncFiles: config.syncFiles,
 			syncSessions: config.syncSessions,
 			extraFiles: config.extraFiles,
 		});
-		if (!options.silent) ctx.ui.notify("pi-sync state initialized; local settings already match remote.", "info");
+		if (!options.silent)
+			ctx.ui.notify("pi-sync state initialized; local settings already match remote.", "info");
 		return;
 	}
 	if (localChanged && remoteChanged && remote && snapshotsMatch(local, remote)) {
-		await writeState(config.profile, {
+		await writeStateForConfig(config, {
 			version: VERSION,
 			profile: config.profile,
 			lastAppliedSnapshot: remote.id,
 			lastRemoteEtag: undefined,
 			lastFileHashes: fileHashMap(remote),
+			syncFiles: config.syncFiles,
 			syncSessions: config.syncSessions,
 			extraFiles: config.extraFiles,
 		});
@@ -532,7 +657,9 @@ async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options
 		return;
 	}
 	if (localChanged && remoteChanged && state.lastAppliedSnapshot) {
-		throw new Error("Both local and remote changed. Run /pisync diff and resolve with push --force or pull --force.");
+		throw new Error(
+			"Both local and remote changed. Run /sync diff and resolve with push --force or pull --force.",
+		);
 	}
 	if (remoteChanged) {
 		await pull(ctx, options);
@@ -543,12 +670,13 @@ async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options
 		return;
 	}
 	if (shouldRefreshSyncedState(remote, state, config)) {
-		await writeState(config.profile, {
+		await writeStateForConfig(config, {
 			version: VERSION,
 			profile: config.profile,
 			lastAppliedSnapshot: remote.id,
 			lastRemoteEtag: undefined,
 			lastFileHashes: fileHashMap(remote),
+			syncFiles: config.syncFiles,
 			syncSessions: config.syncSessions,
 			extraFiles: config.extraFiles,
 		});
@@ -556,20 +684,38 @@ async function syncBoth(ctx: ExtensionCommandContext | ExtensionContext, options
 	if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
 }
 
-async function history(ctx: ExtensionCommandContext) {
-	const config = await loadConfig();
-	const client = new S3Client(config);
+async function history(ctx: ExtensionCommandContext, options: CommandOptions) {
+	const config = await loadConfig(options.target);
+	const client = new S3Client(config, options.signal);
 	const remote = await client.getJson<{ snapshots?: LatestPointer[] }>(historyKey(config));
 	if (remote.missing || !remote.value?.snapshots?.length) {
 		ctx.ui.notify("No remote pi-sync history found.", "info");
 		return;
 	}
 
+	const snapshots = remote.value.snapshots.slice(-20).reverse();
+	const currentSnapshot = snapshots[0]?.snapshot;
+	if (ctx.mode === "tui") {
+		const labels = snapshots.map(
+			(item, index) =>
+				`${index + 1}. ${item.createdAt} · ${safeTerminalText(item.machine)} · ${item.snapshot}${item.snapshot === currentSnapshot ? " (current)" : ""}${item.syncSessions ? " · sessions" : ""}`,
+		);
+		const selected = await ctx.ui.select(
+			`History for target “${safeTerminalText(config.target ?? "default")}”\n\nChoose a snapshot to preview rollback.`,
+			[...labels, "Back"],
+		);
+		if (!selected || selected === "Back") return;
+		const index = labels.indexOf(selected);
+		const snapshot = snapshots[index];
+		if (!snapshot) return;
+		await withLock("rollback", () =>
+			rollback(ctx, { ...options, args: [snapshot.snapshot], yes: false }),
+		);
+		return;
+	}
 	ctx.ui.notify(
-		remote.value.snapshots
-			.slice(-20)
-			.reverse()
-			.map((item) => `${item.snapshot} ${item.createdAt} ${item.machine}`)
+		snapshots
+			.map((item) => `${item.snapshot} ${item.createdAt} ${safeTerminalText(item.machine)}`)
 			.join("\n"),
 		"info",
 	);
@@ -577,10 +723,10 @@ async function history(ctx: ExtensionCommandContext) {
 
 async function rollback(ctx: ExtensionCommandContext, options: CommandOptions) {
 	const target = options.args[0];
-	if (!target) throw new Error("Usage: /pisync rollback <snapshot-id> [--yes]");
+	if (!target) throw new Error("Usage: /sync rollback <snapshot-id> [--yes]");
 
-	const config = await loadConfig();
-	const client = new S3Client(config);
+	const config = await loadConfig(options.target);
+	const client = new S3Client(config, options.signal);
 	const snapshot = await client.getBuffer(snapshotKey(config, target));
 	if (!snapshot.value) throw new Error(`Snapshot not found: ${target}`);
 	const decoded = await decodeSnapshot(snapshot.value);
@@ -589,6 +735,7 @@ async function rollback(ctx: ExtensionCommandContext, options: CommandOptions) {
 		config,
 		{ regenerateId: true },
 	);
+	const local = await createSnapshot(config.profile, snapshotOptionsForContext(ctx, config));
 
 	if (
 		!options.yes &&
@@ -596,40 +743,52 @@ async function rollback(ctx: ExtensionCommandContext, options: CommandOptions) {
 			snapshotIncludesSessions(remote)
 				? "Rollback pi settings and sessions?"
 				: "Rollback pi settings?",
-			formatSnapshotOnlyDiff("Rollback would apply", remote),
+			formatRollbackSummary(config, local, remote, target, protectedSessionPaths(ctx).size),
 		))
 	) {
 		ctx.ui.notify("Rollback cancelled.", "info");
 		return;
 	}
 
+	options.onCommit?.();
 	const backup = await backupLocal(config.profile, snapshotOptionsForContext(ctx, config));
 	const applySessionDir = await sessionDirForApply(ctx, remote);
 	const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+		syncFiles: config.syncFiles,
 		sessionDir: applySessionDir,
 		extraFiles: config.extraFiles,
 	});
-	const latest = await client.getJson<LatestPointer>(latestKey(config));
-	const upload = await snapshotForUpload(client, config, remote, latest, undefined, {
+	const publicationClient = options.onCommit ? new S3Client(config) : client;
+	const latest = await publicationClient.getJson<LatestPointer>(latestKey(config));
+	const upload = await snapshotForUpload(publicationClient, config, remote, latest, undefined, {
 		ignoreUnreadableRemote: true,
 	});
 	const encoded = upload.id === decoded.id ? snapshot.value : await encodeSnapshot(upload);
 	if (upload.id !== decoded.id) {
-		await client.putBuffer(snapshotKey(config, upload.id), encoded, "application/gzip");
+		await publicationClient.putBuffer(snapshotKey(config, upload.id), encoded, "application/gzip");
 	}
 	const pointer = pointerFor(config, upload, sha256(encoded));
-	await client.putJson(latestKey(config), pointer);
-	await updateHistory(client, config, pointer);
-	await writeState(config.profile, {
+	await publicationClient.putJson(latestKey(config), pointer);
+	const historyWarning = await updateHistorySafely(publicationClient, config, pointer);
+	await writeStateForConfig(config, {
 		version: VERSION,
 		profile: config.profile,
 		lastAppliedSnapshot: pointer.snapshot,
 		lastRemoteEtag: undefined,
 		lastFileHashes,
+		syncFiles: config.syncFiles,
 		syncSessions: config.syncSessions,
 		extraFiles: config.extraFiles,
 	});
-	ctx.ui.notify(`Rolled back to ${target}; latest: ${pointer.snapshot}. Backup: ${backup}`, "info");
+	ctx.ui.notify(
+		[
+			`Rolled back target “${config.target ?? "default"}” to ${target}; latest: ${pointer.snapshot}. Backup: ${backup}`,
+			historyWarning,
+		]
+			.filter(Boolean)
+			.join("\n"),
+		historyWarning ? "warning" : "info",
+	);
 	await maybeReload(ctx);
 }
 
@@ -648,6 +807,7 @@ function snapshotOptionsForContext(
 	config: SyncConfig,
 ): SnapshotOptions {
 	return {
+		syncFiles: config.syncFiles,
 		syncSessions: config.syncSessions,
 		sessionDir: sessionDirFromContext(ctx),
 		extraFiles: config.extraFiles,
@@ -670,7 +830,13 @@ function sessionDirFromContext(ctx: ExtensionCommandContext | ExtensionContext)
 
 async function maybeReload(ctx: ExtensionCommandContext | ExtensionContext) {
 	if (!("reload" in ctx)) return;
-	if (ctx.hasUI && (await ctx.ui.confirm("Reload Pi resources now?", "This reloads extensions, skills, prompts, themes, and context files."))) {
+	if (
+		ctx.hasUI &&
+		(await ctx.ui.confirm(
+			"Reload Pi resources now?",
+			"This reloads extensions, skills, prompts, themes, and context files.",
+		))
+	) {
 		await ctx.reload();
 	}
 }
@@ -697,9 +863,9 @@ async function snapshotForUpload(
 	local: Snapshot,
 	latest: RemoteObject<LatestPointer>,
 	remote?: Snapshot,
-	options: { preserveRemote?: boolean; ignoreUnreadableRemote?: boolean } = {},
+	options: { ignoreUnreadableRemote?: boolean } = {},
 ) {
-	if (options.preserveRemote === false || latest.missing || !latest.value) return local;
+	if (latest.missing || !latest.value) return local;
 	let snapshot = remote;
 	if (!snapshot) {
 		try {
@@ -724,12 +890,14 @@ async function uploadSnapshot(
 	await client.putBuffer(snapshotKey(config, snapshot.id), encoded, "application/gzip");
 	const current = await client.getJson<LatestPointer>(latestKey(config));
 	if (!force && remoteIdentity(current) !== remoteIdentity(latest)) {
-		throw new Error("Remote changed while pushing. Run /pisync pull first, then retry.");
+		throw new Error("Remote changed while pushing. Run /sync pull first, then retry.");
 	}
 	await client.putJson(latestKey(config), pointer);
 	const verified = await client.getJson<LatestPointer>(latestKey(config));
 	if (verified.value?.snapshot !== pointer.snapshot) {
-		throw new Error("Remote latest changed immediately after push. Run /pisync status before continuing.");
+		throw new Error(
+			"Remote latest changed immediately after push. Run /sync status before continuing.",
+		);
 	}
 	return pointer;
 }
@@ -743,8 +911,10 @@ async function readRemoteSnapshotRaw(client: S3Client, config: SyncConfig) {
 	const latest = await client.getJson<LatestPointer>(latestKey(config));
 	if (latest.missing || !latest.value) return undefined;
 	const object = await client.getBuffer(snapshotKey(config, latest.value.snapshot));
-	if (!object.value) throw new Error(`Remote latest points to missing snapshot: ${latest.value.snapshot}`);
-	if (sha256(object.value) !== latest.value.sha256) throw new Error("Remote snapshot checksum mismatch.");
+	if (!object.value)
+		throw new Error(`Remote latest points to missing snapshot: ${latest.value.snapshot}`);
+	if (sha256(object.value) !== latest.value.sha256)
+		throw new Error("Remote snapshot checksum mismatch.");
 	return decodeSnapshot(object.value);
 }
 
@@ -755,7 +925,8 @@ async function encodeSnapshot(snapshot: Snapshot) {
 async function decodeSnapshot(buffer: Buffer): Promise<Snapshot> {
 	const decoded = await gunzipAsync(buffer);
 	const parsed = JSON.parse(decoded.toString("utf8")) as Snapshot;
-	if (parsed.version !== VERSION || !Array.isArray(parsed.files)) throw new Error("Unsupported snapshot format.");
+	if (parsed.version !== VERSION || !Array.isArray(parsed.files))
+		throw new Error("Unsupported snapshot format.");
 	return parsed;
 }
 
@@ -768,8 +939,19 @@ export async function backupLocal(profile: string, options: SnapshotOptions = {}
 	return backupPath;
 }
 
+async function updateHistorySafely(client: S3Client, config: SyncConfig, pointer: LatestPointer) {
+	try {
+		await updateHistory(client, config, pointer);
+		return undefined;
+	} catch (error) {
+		return `Remote snapshot is active, but history could not be updated: ${errorMessage(error)}. Run /sync doctor before relying on history.`;
+	}
+}
+
 async function updateHistory(client: S3Client, config: SyncConfig, pointer: LatestPointer) {
-	const object = await client.getJson<{ version: number; snapshots: LatestPointer[] }>(historyKey(config));
+	const object = await client.getJson<{ version: number; snapshots: LatestPointer[] }>(
+		historyKey(config),
+	);
 	const snapshots = object.value?.snapshots ?? [];
 	const next = [
 		...snapshots.filter((snapshot) => snapshot.snapshot !== pointer.snapshot),
@@ -778,216 +960,40 @@ async function updateHistory(client: S3Client, config: SyncConfig, pointer: Late
 	await client.putJson(historyKey(config), { version: VERSION, snapshots: next });
 }
 
-function formatDiff(local: Snapshot, remote: Snapshot) {
-	const localMap = fileHashMap(local);
-	const remoteMap = fileHashMap(remote);
-	const allPaths = [...new Set([...Object.keys(localMap), ...Object.keys(remoteMap)])].sort();
-	const lines = [`local: ${local.files.length} files`, `remote: ${remote.id} (${remote.files.length} files)`, ""];
-	let changed = 0;
-	for (const filePath of allPaths) {
-		if (!localMap[filePath]) {
-			lines.push(`+ ${filePath}`);
-			changed += 1;
-		} else if (!remoteMap[filePath]) {
-			lines.push(`- ${filePath}`);
-			changed += 1;
-		} else if (localMap[filePath] !== remoteMap[filePath]) {
-			lines.push(`~ ${filePath}`);
-			changed += 1;
-		}
-	}
-	if (changed === 0) lines.push("No file differences.");
-	return lines.join("\n");
-}
-
-function formatSnapshotOnlyDiff(title: string, snapshot: Snapshot) {
-	return [`${title}: ${snapshot.id}`, ...snapshot.files.map((file) => `+ ${file.path}`)].join("\n");
-}
-
-function formatPushSummary(
-	local: Snapshot,
-	latest: RemoteObject<LatestPointer>,
-	preservedRemoteFileCount = 0,
-) {
-	return [
-		`Upload ${local.files.length} files from ${agentDir()}.`,
-		latest.value ? `Remote latest: ${latest.value.snapshot}` : "Remote latest: empty",
-		preservedRemoteFileCount > 0
-			? `Possible secrets in locally managed files were scanned before this prompt; ${preservedRemoteFileCount} preserved remote file(s) were not rescanned.`
-			: "Possible secrets were scanned before this prompt.",
-	].join("\n");
-}
-
-function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncConfig) {
-	return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
-}
-
-function remoteChangedSinceState(
-	latest: RemoteObject<LatestPointer>,
-	state: SyncState,
-	config: SyncConfig,
-) {
-	if (latest.missing) return Boolean(state.lastAppliedSnapshot);
-	if (latest.value?.snapshot !== state.lastAppliedSnapshot) return true;
-	if (extraFilesChanged(state, config)) return true;
-	return config.syncSessions && state.syncSessions !== true && latest.value?.syncSessions === true;
-}
-
-export function hasRemoteChanges(
-	remote: Snapshot,
-	state: SyncState,
-	config: SyncConfig,
-	ignoredPaths = new Set<string>(),
-) {
-	if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
-	return !snapshotHashesMatchState(filterSnapshotForConfigPolicy(remote, config), state, config, ignoredPaths);
-}
-
-function remoteIdentity(remote: RemoteObject<LatestPointer>) {
-	return remote.missing ? "missing" : (remote.value?.snapshot ?? "unknown");
-}
-
-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;
-}
-
-function fileHashMap(snapshot: Snapshot) {
-	return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
-}
-
-function stateHashMapForConfig(state: SyncState, config: Pick<SyncConfig, "syncSessions" | "extraFiles">) {
-	const extraFilePaths = extraFilePathsByLower(config.extraFiles);
-	const extraFiles = new Set(extraFilePaths.keys());
-	return Object.fromEntries(
-		Object.entries(state.lastFileHashes)
-			.filter(([filePath]) => isConfiguredSnapshotPath(filePath, config, extraFiles))
-			.map(([filePath, hash]) => [canonicalSnapshotPathForConfig(filePath, extraFilePaths), hash]),
-	);
-}
-
-function snapshotHashesMatchState(
-	snapshot: Snapshot,
-	state: SyncState,
-	config: Pick<SyncConfig, "syncSessions" | "extraFiles">,
-	ignoredPaths = new Set<string>(),
-) {
-	return sameHashes(
-		withoutHashPaths(fileHashMap(snapshot), ignoredPaths),
-		withoutHashPaths(stateHashMapForConfig(state, config), ignoredPaths),
-	);
-}
-
-function snapshotsMatch(left: Snapshot, right: Snapshot) {
-	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))),
-	);
-}
-
-function syncPolicyChanged(state: SyncState, config: Pick<SyncConfig, "syncSessions" | "extraFiles">) {
-	return (state.syncSessions ?? false) !== config.syncSessions || extraFilesChanged(state, config);
-}
-
-function shouldRefreshSyncedState(
-	remote: Snapshot,
-	state: SyncState,
-	config: Pick<SyncConfig, "syncSessions" | "extraFiles">,
-) {
-	return remote.id !== state.lastAppliedSnapshot || syncPolicyChanged(state, config);
-}
-
-function extraFilesChanged(state: SyncState, config: Pick<SyncConfig, "extraFiles">) {
-	return !sameStringSet(normalizeExtraFiles(state.extraFiles), normalizeExtraFiles(config.extraFiles));
-}
-
-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 countPreservedRemoteFiles(local: Snapshot, upload: Snapshot) {
-	const localPaths = new Set(local.files.map((file) => file.path));
-	return upload.files.filter((file) => !localPaths.has(file.path)).length;
-}
-
-export function settingsHashMap(snapshot: Snapshot) {
-	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]),
-	);
-}
-
-export function settingsHashMapFromState(state: SyncState) {
-	return Object.fromEntries(
-		Object.entries(state.lastFileHashes).filter(([filePath]) => !isSessionPath(filePath)),
-	);
-}
-
-export function settingsHashesMatchState(remote: Snapshot, state: SyncState) {
-	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,
-	);
-}
-
-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);
-}
-
-function sha256(value: Buffer) {
-	return createHash("sha256").update(value).digest("hex");
-}
-
-function redact(value: string) {
-	return value.length <= 8 ? "configured" : `${value.slice(0, 4)}…${value.slice(-4)}`;
-}
-
-function errorMessage(error: unknown) {
-	return error instanceof Error ? error.message : String(error);
-}
-
 export { completeSyncArguments, parseOptions, splitArgs } from "./command.js";
-export { isCloudflareR2Endpoint, isEnabled, isExplicitlyEnabled, loadConfig, sessionTokenWarnings } from "./config.js";
-export { encodeKey, posixJoin, safeJoin, safeName } from "./paths.js";
 export {
-	addTopLevelCaseVariantDeletes,
-	appliedFileHashMap,
-	preflightSnapshotApply,
-	protectSnapshotApplyPlan,
-} from "./snapshot-apply.js";
+	isCloudflareR2Endpoint,
+	isEnabled,
+	isExplicitlyEnabled,
+	loadConfig,
+	sessionTokenWarnings,
+} from "./config.js";
+export { encodeKey, posixJoin, safeJoin, safeName } from "./paths.js";
 export {
-	collectFiles,
 	canonicalSnapshotPathForConfig,
+	collectFiles,
 	filterSnapshotForConfigPolicy,
 	isConfiguredSnapshotPath,
 	isDeniedPath,
 	isSessionPath,
-	sessionSnapshotPathFromAbsolute,
 	mergeRemotePreservedFiles,
 	mergeRemoteSessionFiles,
 	scanSnapshot,
+	sessionSnapshotPathFromAbsolute,
 	snapshotWithoutSessions,
 } from "./snapshot.js";
+export {
+	addTopLevelCaseVariantDeletes,
+	appliedFileHashMap,
+	preflightSnapshotApply,
+	protectSnapshotApplyPlan,
+} from "./snapshot-apply.js";
+export {
+	canPullRemoteSessionsOnFirstSync,
+	canPullRemoteSettingsOnFirstSync,
+	hasRemoteChanges,
+	sessionHashMap,
+	settingsHashesMatchState,
+	settingsHashMap,
+	settingsHashMapFromState,
+} from "./sync-state.js";