@narumitw/pi-sync 0.49.6 → 0.49.8

package/src/remote-snapshot.ts

@@ -1,9 +1,10 @@
+import { syncConfigReviewFingerprint } from "./config.js";
 import type { RemoteHead, SyncBackend } from "./sync-backend.js";
 import { safeTerminalText } from "./sync-format.js";
 import {
 	inspectRemoteSelection,
-	RemoteSelectionMismatchError,
 	type RemoteSelectionState,
+	remoteSelectionMismatch,
 	sameSyncInclude,
 	snapshotSelectionInclude,
 } from "./sync-policy.js";
@@ -37,7 +38,7 @@ export async function readSnapshotForHead(
 export function requireCompatibleRemoteSelection(config: AnySyncConfig, snapshot: Snapshot) {
 	const state = inspectRemoteSelection(config.include, snapshot);
 	if (state.kind === "different") {
-		throw new RemoteSelectionMismatchError(config.include, state.include);
+		throw remoteSelectionMismatch(config, state.include, syncConfigReviewFingerprint(config));
 	}
 }
 

package/src/settings-management.ts

@@ -9,6 +9,13 @@ import {
 } from "./config.js";
 import type { PiSyncSettingsV3, StorageConnectionSettings, SyncSetupSettings } from "./types.js";
 
+export class SyncSetupReviewChangedError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "SyncSetupReviewChangedError";
+	}
+}
+
 export async function saveNewV3Settings(
 	input: {
 		setupName: string;
@@ -119,7 +126,7 @@ export async function updateSyncSetup(
 			options.expectedInclude &&
 			!sameNames(normalizeSyncInclude(setup.sync.include), options.expectedInclude)
 		) {
-			throw new Error(
+			throw new SyncSetupReviewChangedError(
 				`Sync setup “${name}” included content changed while it was open; reopen it and review the current selection.`,
 			);
 		}
@@ -133,7 +140,7 @@ export async function updateSyncSetup(
 					options.expectedStorage,
 				)
 			) {
-				throw new Error(
+				throw new SyncSetupReviewChangedError(
 					`Sync setup “${name}” storage changed while it was open; reopen it and review the current storage location.`,
 				);
 			}

package/src/settings-ui.ts

@@ -2,6 +2,7 @@ import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
 import type { RunRoute } from "./cancellable-operation.js";
 import { loadConfig, localConfigPath } from "./config.js";
+import { dispatchManagerResult } from "./manager-result-dispatcher.js";
 import { updateSyncSetup } from "./settings-management.js";
 import {
 	SETUP_SWITCH_ACTION_OPTIONS,
@@ -67,9 +68,8 @@ export async function showSyncSettings(
 					},
 					{
 						id: "remoteInclude",
-						label: "Remote included content",
-						description:
-							"Compare portable remote selection, then adopt it or keep local settings without pulling files.",
+						label: "Compare synced content",
+						description: "Review this device and remote content lists before choosing either one.",
 						currentValue: "Review",
 						action: "remote-include",
 					},
@@ -126,8 +126,24 @@ export async function showSyncSettings(
 				const reviewSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
 				const { showRemoteSelectionReview } = await import("./remote-selection-ui.js");
 				if (reviewSignal.aborted) return { kind: "rejected" };
-				await showRemoteSelectionReview(ctx, setupName, reviewSignal);
-				return reviewSignal.aborted ? { kind: "rejected" } : { kind: "stay" };
+				const review = await showRemoteSelectionReview(ctx, setupName, reviewSignal, undefined, {
+					origin: "settings",
+					runRoute,
+				});
+				if (reviewSignal.aborted) return { kind: "rejected" };
+				if (review.kind === "route-result") {
+					const disposition = await dispatchManagerResult(
+						ctx,
+						review.result,
+						review.route,
+						runRoute,
+						reviewSignal,
+					);
+					return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+				}
+				return review.kind === "closed" || review.kind === "stale"
+					? { kind: "close" }
+					: { kind: "stay" };
 			},
 		},
 	});

package/src/sync-attention.ts

@@ -0,0 +1,100 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { syncConfigReviewFingerprint } from "./config.js";
+import { safeTerminalText } from "./sync-format.js";
+import {
+	compareSyncInclude,
+	type RemoteSelectionDecision,
+	sameSyncInclude,
+} from "./sync-policy.js";
+import type { AnySyncConfig } from "./types.js";
+
+const STATUS_KEY = "sync";
+const WIDGET_KEY = "sync:attention";
+
+export type SyncAttentionOrigin = "sync" | "pull" | "push";
+
+export interface SyncAttentionState {
+	decision: RemoteSelectionDecision;
+	origin: SyncAttentionOrigin;
+	offered: boolean;
+}
+
+export function syncAttentionMatchesConfig(attention: SyncAttentionState, config: AnySyncConfig) {
+	return (
+		attention.decision.setupName === config.setupName &&
+		attention.decision.configIdentity === syncConfigReviewFingerprint(config) &&
+		sameSyncInclude(attention.decision.localInclude, config.include)
+	);
+}
+
+export interface SyncAttentionController {
+	set(decision: RemoteSelectionDecision, origin: SyncAttentionOrigin): void;
+	current(): SyncAttentionState | undefined;
+	markOffered(): boolean;
+	clear(ctx: ExtensionContext): void;
+	reset(ctx: ExtensionContext): void;
+	publish(ctx: ExtensionContext): void;
+}
+
+export function createSyncAttentionController(): SyncAttentionController {
+	let state: SyncAttentionState | undefined;
+
+	return {
+		set(decision, origin) {
+			state = { decision, origin, offered: false };
+		},
+		current() {
+			return state;
+		},
+		markOffered() {
+			if (!state || state.offered) return false;
+			state = { ...state, offered: true };
+			return true;
+		},
+		clear(ctx) {
+			state = undefined;
+			clearAttentionPresentation(ctx);
+		},
+		reset(ctx) {
+			state = undefined;
+			clearAttentionPresentation(ctx);
+		},
+		publish(ctx) {
+			if (!state) {
+				clearAttentionPresentation(ctx);
+				return;
+			}
+			const presentation = attentionPresentation(state.decision);
+			ctx.ui.setStatus(STATUS_KEY, presentation.status);
+			if (ctx.mode !== "tui") return;
+			ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => ({
+				render(width: number) {
+					const safeWidth = Math.max(1, width);
+					return presentation.lines.map((line, index) =>
+						truncateToWidth(theme.fg(index === 0 ? "warning" : "muted", line), safeWidth, "…"),
+					);
+				},
+				invalidate() {},
+			}));
+		},
+	};
+}
+
+function attentionPresentation(decision: RemoteSelectionDecision) {
+	const setupName = safeTerminalText(decision.setupName);
+	const comparison = compareSyncInclude(decision.localInclude, decision.remoteInclude);
+	const difference =
+		comparison.remoteOnly.length === 0 && comparison.localOnly.length === 0
+			? "Only list order differs"
+			: `Remote ${comparison.remoteOnly.length} · Device ${comparison.localOnly.length}`;
+	return {
+		status: "review needed",
+		lines: [`Pi Sync needs review · ${setupName}`, difference, "No changes · Run /sync to review"],
+	};
+}
+
+function clearAttentionPresentation(ctx: ExtensionContext) {
+	ctx.ui.setStatus(STATUS_KEY, undefined);
+	ctx.ui.setWidget(WIDGET_KEY, undefined);
+}

package/src/sync-extension.ts

@@ -36,11 +36,22 @@ import {
 	stateDirectoryMigrationNotice,
 	withStateDirectoryAccess,
 } from "./state-directory.js";
+import {
+	createSyncAttentionController,
+	type SyncAttentionController,
+	type SyncAttentionOrigin,
+	syncAttentionMatchesConfig,
+} from "./sync-attention.js";
 import {
 	errorMessage,
 	isSyncDecisionRequiredError,
 	SetupPullRequiresUiError,
 } from "./sync-errors.js";
+import {
+	formatRemoteSelectionMismatch,
+	type RemoteSelectionDecision,
+	RemoteSelectionMismatchError,
+} from "./sync-policy.js";
 import type { AnySyncConfig, CommandOptions, SnapshotOptions } from "./types.js";
 
 const STATUS_KEY = "sync";
@@ -84,6 +95,7 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 			dependencies.loadSyncOperations ?? (() => import("./sync-operations.js")),
 		),
 	};
+	const attention = createSyncAttentionController();
 	let sessionAbort = new AbortController();
 	let shutdownAbort: AbortController | undefined;
 
@@ -96,7 +108,7 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 					"/sync requires TUI or RPC mode so results and safety prompts are observable.",
 				);
 			}
-			const run = () => handleCommand(args, ctx, sessionAbort.signal, loaders);
+			const run = () => handleCommand(args, ctx, sessionAbort.signal, loaders, attention);
 			if (splitArgs(args)[0] === "migrate-state") await run();
 			else await withStateDirectoryAccess(run);
 		},
@@ -108,17 +120,38 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 		sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
 		sessionAbort = new AbortController();
 		const signal = sessionAbort.signal;
-		ctx.ui.setStatus(STATUS_KEY, undefined);
+		attention.reset(ctx);
+		let decision: RemoteSelectionDecision | undefined;
 		try {
-			await withStateDirectoryAccess(() => startSession(ctx, signal, loaders));
+			decision = await withStateDirectoryAccess(() => startSession(ctx, signal, loaders));
 		} catch (error) {
 			if (signal.aborted) return;
 			ctx.ui.notify(`pi-sync state access failed: ${errorMessage(error)}`, "error");
+			return;
+		}
+		if (!decision || signal.aborted) return;
+		attention.set(decision, "sync");
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(
+				`pi-sync auto sync skipped: ${formatRemoteSelectionMismatch(
+					decision.setupName,
+					decision.localInclude,
+					decision.remoteInclude,
+				)}\nRPC review is read-only.`,
+				"warning",
+			);
+		} else if (attention.markOffered()) {
+			await resolveSelectionAttention(ctx, attention, signal, loaders, {
+				cancelLabel: "Later",
+				withStateAccess: withStateDirectoryAccess,
+			});
 		}
+		if (!signal.aborted) attention.publish(ctx);
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {
 		sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
+		attention.reset(ctx);
 		shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
 		const controller = new AbortController();
 		shutdownAbort = controller;
@@ -171,7 +204,7 @@ async function startSession(ctx: ExtensionContext, signal: AbortSignal, loaders:
 	const migrationNotice = consumeLocalConfigMigrationNotice();
 	if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
 	if (signal.aborted) return;
-	await autoSync(ctx, signal, loaders);
+	return autoSync(ctx, signal, loaders);
 }
 
 async function handleCommand(
@@ -179,6 +212,7 @@ async function handleCommand(
 	ctx: ExtensionCommandContext,
 	sessionSignal: AbortSignal,
 	loaders: SyncLoaders,
+	attention: SyncAttentionController,
 ) {
 	if (!rawArgs.trim()) {
 		try {
@@ -196,17 +230,173 @@ async function handleCommand(
 						target,
 					),
 				sessionSignal,
+				{
+					getAttention: () => attention.current(),
+					onSelectionResolved: (expected) => {
+						if (attention.current() === expected) attention.clear(ctx);
+					},
+				},
 			);
 		} catch (error) {
 			if (sessionSignal.aborted) return;
 			ctx.ui.setStatus(STATUS_KEY, undefined);
 			ctx.ui.notify(errorMessage(error), "error");
 		}
+		if (!sessionSignal.aborted) attention.publish(ctx);
 		return;
 	}
 	const result = await executeCommand(rawArgs, ctx, sessionSignal, loaders);
 	if (result.kind === "decision-required") {
 		ctx.ui.notify(result.decision.directMessage, "error");
+	} else if (result.kind === "remote-selection-required") {
+		const origin = directSelectionOrigin(rawArgs);
+		if (origin) attention.set(result.decision, origin);
+		const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
+		if (origin && ctx.mode === "tui" && !deterministic) {
+			await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
+		} else {
+			ctx.ui.notify(
+				formatRemoteSelectionMismatch(
+					result.decision.setupName,
+					result.decision.localInclude,
+					result.decision.remoteInclude,
+				),
+				"error",
+			);
+		}
+	}
+	await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
+	await reconcileSelectionAttention(ctx, attention, sessionSignal);
+	if (!sessionSignal.aborted) attention.publish(ctx);
+}
+
+async function clearAttentionAfterCompletedOperation(
+	rawArgs: string,
+	result: RunRouteResult,
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+) {
+	if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
+	const [command, ...rest] = splitArgs(rawArgs);
+	if (command !== "sync" && command !== "pull" && command !== "push") return;
+	const current = attention.current();
+	if (!current) return;
+	try {
+		const options = parseOptions(rest);
+		const setupName = options.setup ?? (await loadConfig()).setupName;
+		if (signal.aborted || attention.current() !== current) return;
+		if (current.decision.setupName === setupName) attention.clear(ctx);
+	} catch {
+		// Attention reconciliation below owns malformed or concurrently changed settings.
+	}
+}
+
+async function reconcileSelectionAttention(
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+) {
+	const current = attention.current();
+	if (!current || signal.aborted) return;
+	try {
+		const config = await loadConfig(current.decision.setupName);
+		if (signal.aborted || attention.current() !== current) return;
+		if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
+	} catch {
+		if (!signal.aborted && attention.current() === current) attention.clear(ctx);
+	}
+}
+
+function directSelectionOrigin(rawArgs: string): SyncAttentionOrigin | undefined {
+	const command = splitArgs(rawArgs)[0];
+	return command === "sync" || command === "pull" || command === "push" ? command : undefined;
+}
+
+async function resolveSelectionAttention(
+	ctx: ExtensionContext,
+	attention: SyncAttentionController,
+	signal: AbortSignal,
+	loaders: SyncLoaders,
+	options: {
+		cancelLabel?: string;
+		withStateAccess?: <T>(task: () => Promise<T>) => Promise<T>;
+	} = {},
+) {
+	const current = attention.current();
+	if (!current || signal.aborted) return;
+	const { dispatchManagerResult } = await import("./manager-result-dispatcher.js");
+	if (signal.aborted || attention.current() !== current) return;
+	await dispatchManagerResult(
+		ctx,
+		{ kind: "remote-selection-required", decision: current.decision },
+		current.origin,
+		(route, actionSignal, onCommit, target) => {
+			const execute = () =>
+				executeRecoveryCommand(
+					route,
+					ctx,
+					combineSignals(signal, actionSignal),
+					loaders,
+					onCommit,
+					target,
+				);
+			return options.withStateAccess ? options.withStateAccess(execute) : execute();
+		},
+		signal,
+		{
+			cancelLabel: options.cancelLabel,
+			withStateAccess: options.withStateAccess,
+			onSelectionResolved: () => {
+				if (attention.current() === current) attention.clear(ctx);
+			},
+		},
+	);
+}
+
+async function executeRecoveryCommand(
+	rawArgs: string,
+	ctx: ExtensionContext,
+	signal: AbortSignal | undefined,
+	loaders: SyncLoaders,
+	onCommit?: () => void,
+	setup?: string,
+): Promise<RunRouteResult> {
+	try {
+		const [subcommand, ...rest] = splitArgs(rawArgs);
+		if (subcommand !== "sync" && subcommand !== "pull" && subcommand !== "push") {
+			throw new Error(`Unsupported sync recovery route: ${subcommand ?? "missing"}`);
+		}
+		const options = parseOptions(rest);
+		if (setup !== undefined) options.setup = setup;
+		if (signal) options.signal = signal;
+		if (onCommit) options.onCommit = onCommit;
+		options.reload = false;
+		options.auto = false;
+		validateCommandOptions(subcommand, options);
+		const operations = await loaders.operations();
+		throwIfAborted(options.signal);
+		if (subcommand === "push") {
+			const outcome = await withLock("push", () => operations.push(ctx, options));
+			return { kind: "completed", ...(outcome ? { outcome } : {}) };
+		}
+		if (subcommand === "pull") {
+			const outcome = await withLock("pull", () => operations.pull(ctx, options));
+			return { kind: "completed", ...(outcome ? { outcome } : {}) };
+		}
+		await withLock("sync", () => operations.syncBoth(ctx, options));
+		return { kind: "completed" };
+	} catch (error) {
+		if (signal?.aborted) return { kind: "failed" };
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		if (error instanceof RemoteSelectionMismatchError) {
+			return { kind: "remote-selection-required", decision: error.decision };
+		}
+		if (isSyncDecisionRequiredError(error)) {
+			return { kind: "decision-required", decision: error.decision };
+		}
+		ctx.ui.notify(errorMessage(error), "error");
+		return { kind: "failed" };
 	}
 }
 
@@ -324,6 +514,9 @@ async function executeCommand(
 		if (signal?.aborted) return { kind: "failed" };
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		if (error instanceof SetupPullRequiresUiError) throw error;
+		if (error instanceof RemoteSelectionMismatchError) {
+			return { kind: "remote-selection-required", decision: error.decision };
+		}
 		if (isSyncDecisionRequiredError(error)) {
 			return { kind: "decision-required", decision: error.decision };
 		}
@@ -359,7 +552,11 @@ async function migrateStateDirectory(ctx: ExtensionCommandContext, options: Comm
 	ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
 }
 
-async function autoSync(ctx: ExtensionContext, signal: AbortSignal, loaders: SyncLoaders) {
+async function autoSync(
+	ctx: ExtensionContext,
+	signal: AbortSignal,
+	loaders: SyncLoaders,
+): Promise<RemoteSelectionDecision | undefined> {
 	try {
 		const partial = await loadPartialConfig();
 		throwIfAborted(signal);
@@ -377,6 +574,7 @@ async function autoSync(ctx: ExtensionContext, signal: AbortSignal, loaders: Syn
 	} catch (error) {
 		if (signal.aborted || isMissingConfigError(error)) return;
 		ctx.ui.setStatus(STATUS_KEY, undefined);
+		if (error instanceof RemoteSelectionMismatchError) return error.decision;
 		ctx.ui.notify(`pi-sync auto sync skipped: ${errorMessage(error)}`, "warning");
 	}
 }

package/src/sync-operations.ts

@@ -7,6 +7,7 @@ import {
 	readStateForConfig,
 	sessionDirForApply,
 	stateDir,
+	syncConfigReviewFingerprint,
 	syncSessionsWarnings,
 	writeStateForConfig,
 } from "./config.js";
@@ -46,7 +47,7 @@ import {
 	publicationCapabilityDescription,
 	safeTerminalText,
 } from "./sync-format.js";
-import { inspectRemoteSelection, RemoteSelectionMismatchError } from "./sync-policy.js";
+import { inspectRemoteSelection, remoteSelectionMismatch } from "./sync-policy.js";
 import {
 	canPullRemoteSessionsOnFirstSync,
 	canPullRemoteSettingsOnFirstSync,
@@ -923,7 +924,8 @@ async function readRemoteSnapshot(
 	const snapshot = await readSnapshotForHead(backend, head, signal);
 	const selectionState = inspectRemoteSelection(config.include, snapshot);
 	if (!options.allowSelectionDifference && selectionState.kind === "different") {
-		throw new RemoteSelectionMismatchError(config.include, selectionState.include);
+		const configIdentity = syncConfigReviewFingerprint(config);
+		throw remoteSelectionMismatch(config, selectionState.include, configIdentity);
 	}
 	return {
 		head,

package/src/sync-policy.ts

@@ -206,22 +206,81 @@ export function inspectRemoteSelection(
 		: { kind: "different", include: remoteInclude, ...comparison };
 }
 
+export interface RemoteSelectionDecision {
+	setupName: string;
+	configIdentity: string;
+	localInclude: readonly string[];
+	remoteInclude: readonly string[];
+}
+
 export class RemoteSelectionMismatchError extends Error {
+	readonly decision: RemoteSelectionDecision;
+	readonly setupName: string;
 	readonly localInclude: string[];
 	readonly remoteInclude: string[];
 
-	constructor(localInclude: unknown, remoteInclude: unknown) {
+	constructor(
+		setupName: string,
+		localInclude: unknown,
+		remoteInclude: unknown,
+		configIdentity = JSON.stringify([setupName, normalizeSyncInclude(localInclude)]),
+	) {
 		const local = normalizeSyncInclude(localInclude);
 		const remote = normalizeSyncInclude(remoteInclude);
-		super(
-			"Remote included content differs from this sync setup. Review Remote included content in /sync Settings, or use a reviewed force push to keep local selection.",
-		);
+		super(formatRemoteSelectionMismatch(setupName, local, remote));
 		this.name = "RemoteSelectionMismatchError";
+		this.setupName = setupName;
 		this.localInclude = local;
 		this.remoteInclude = remote;
+		this.decision = {
+			setupName,
+			configIdentity,
+			localInclude: [...local],
+			remoteInclude: [...remote],
+		};
 	}
 }
 
+export function remoteSelectionMismatch(
+	config: { setupName: string; include: unknown },
+	remoteInclude: unknown,
+	configIdentity?: string,
+) {
+	return new RemoteSelectionMismatchError(
+		config.setupName,
+		config.include,
+		remoteInclude,
+		configIdentity,
+	);
+}
+
+export function formatRemoteSelectionMismatch(
+	setupName: string,
+	localInclude: readonly string[],
+	remoteInclude: readonly string[],
+) {
+	const comparison = compareSyncInclude(localInclude, remoteInclude);
+	const lines = [
+		`Synced content differs for sync setup “${stripTerminalControls(setupName)}”.`,
+		`Remote-only: ${comparison.remoteOnly.join(", ") || "none"}`,
+		`This-device-only: ${comparison.localOnly.join(", ") || "none"}`,
+	];
+	if (comparison.remoteOnly.length === 0 && comparison.localOnly.length === 0) {
+		lines.push(
+			"Only ordering differs.",
+			`Remote order: ${remoteInclude.join(", ") || "none"}`,
+			`This device order: ${localInclude.join(", ") || "none"}`,
+		);
+	}
+	lines.push("Run /sync in TUI to review both content lists and choose what happens next.");
+	return lines.join("\n");
+}
+
+function stripTerminalControls(value: string) {
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: Escape untrusted terminal controls.
+	return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, "?");
+}
+
 export function discoverLegacySnapshotInclude(snapshot: Pick<Snapshot, "files">) {
 	const builtIns = new Set<BuiltInSyncFile>();
 	const custom = new Set<string>();

package/src/sync-resolution-ui.ts

@@ -1,18 +1,27 @@
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import { type RunRoute, runCancellableOperation } from "./cancellable-operation.js";
+import {
+	type RunRoute,
+	type RunRouteResult,
+	runCancellableOperation,
+} from "./cancellable-operation.js";
 import { loadConfig, syncConfigReviewIdentity } from "./config.js";
 import type { SyncDecision, SyncResolutionDirection } from "./sync-decision.js";
 import { errorMessage, safeTerminalText } from "./sync-format.js";
 
 export type SyncResolutionResult =
 	| { kind: "resolved"; direction: SyncResolutionDirection }
+	| {
+			kind: "route-result";
+			result: RunRouteResult;
+			route: SyncResolutionDirection;
+	  }
 	| { kind: "back" }
 	| { kind: "closed" }
 	| { kind: "stale" };
 
 export async function showSyncResolution(
-	ctx: ExtensionCommandContext,
+	ctx: ExtensionContext,
 	initialDecision: SyncDecision,
 	runRoute: RunRoute,
 	sessionSignal?: AbortSignal,
@@ -21,7 +30,8 @@ export async function showSyncResolution(
 	type Action = "push" | "pull" | "back";
 	let currentDecision = initialDecision;
 	let resolvedDirection: SyncResolutionDirection | undefined;
-	const menu = defineMenu<SyncDecision, Screen, Action, ExtensionCommandContext>({
+	let chainedResult: { result: RunRouteResult; route: SyncResolutionDirection } | undefined;
+	const menu = defineMenu<SyncDecision, Screen, Action, ExtensionContext>({
 		start: "resolve",
 		screens: {
 			resolve: ({ state }) => ({
@@ -104,6 +114,10 @@ export async function showSyncResolution(
 			currentDecision = result.decision;
 			return { kind: "stay" as const };
 		}
+		if (result.kind === "remote-selection-required") {
+			chainedResult = { result, route: direction };
+			return { kind: "close" as const };
+		}
 		if (result.kind === "completed") {
 			if (result.outcome === "cancelled") return { kind: "stay" as const };
 			resolvedDirection = direction;
@@ -119,6 +133,7 @@ export async function showSyncResolution(
 		onError: (_menuCtx, error) => ctx.ui.notify(errorMessage(error), "error"),
 	});
 	if (sessionSignal?.aborted || result.kind === "stale") return { kind: "stale" };
+	if (chainedResult) return { kind: "route-result", ...chainedResult };
 	if (resolvedDirection) return { kind: "resolved", direction: resolvedDirection };
 	if (result.kind === "closed") {
 		return result.reason === "back" ? { kind: "back" } : { kind: "closed" };