diff --git a/e2e/deployment.spec.ts b/e2e/deployment.spec.ts
new file mode 100644
index 000000000..9f110d065
--- /dev/null
+++ b/e2e/deployment.spec.ts
@@ -0,0 +1,287 @@
+/** Deployment diff over an in-memory server: no SSH or filesystem writes. */
+import { test, expect } from "./fixtures";
+import type { Page } from "@playwright/test";
+
+test("native deployment entry fills its own window and exposes minimize and maximize controls", async ({
+  page,
+}, info) => {
+  const errors: string[] = [];
+  page.on("pageerror", (error) => errors.push(error.message));
+  await page.route("**/deployment-window-test", (route) =>
+    route.fulfill({
+      contentType: "text/html",
+      body: '<!doctype html><html><head></head><body><div id="root"></div></body></html>',
+    }),
+  );
+  await page.goto("/deployment-window-test");
+  await page.evaluate(async () => {
+    const refreshModule = "/@react-refresh";
+    const { default: refresh } = await import(/* @vite-ignore */ refreshModule);
+    refresh.injectIntoGlobalHook(window);
+    Object.assign(window, {
+      $RefreshReg$: () => {},
+      $RefreshSig$: () => (type: unknown) => type,
+      __vite_plugin_react_preamble_installed__: true,
+    });
+    const mocksModule = "/node_modules/@tauri-apps/api/mocks.js";
+    const { mockIPC, mockWindows } = await import(/* @vite-ignore */ mocksModule);
+    const calls: string[] = [];
+    (window as unknown as { deploymentCalls: string[] }).deploymentCalls = calls;
+    const settings = {
+      appearance: { theme: "dark", syncWithOs: false },
+      deployment: { servers: [{ id: "staging", name: "Staging", kind: "local", rootPath: "/srv/app" }] },
+    };
+    let launch = true;
+    const local = "<?php\nclass Perfil {\n    public $name = 'Local';\n}\n";
+    const remote = "<?php\nclass Perfil {\n    public $name = 'Remote';\n}\n";
+    mockWindows("deployment-main", "main");
+    mockIPC(
+      (command: string, args: Record<string, unknown>) => {
+        calls.push(command);
+        if (/deploy_(upload|download|sync|delete)|doc_save|fs_write/.test(command)) throw new Error("Unexpected write");
+        if (command === "app_info")
+          return { platform: "windows", version: "test", configDir: "/config", wayland: false };
+        if (command === "settings_get") return settings;
+        if (command === "project_current") return { root: "/second", name: "Second", settings };
+        if (command === "window_take_launch") {
+          if (!launch) return null;
+          launch = false;
+          return { deployment: { server: "staging", paths: ["/second/perfil.php"] } };
+        }
+        if (command === "deploy_coverage") return [{ server: "staging", paths: ["/second/perfil.php"], skipped: [] }];
+        if (command === "deploy_compare")
+          return [
+            {
+              path: "perfil.php",
+              remotePath: "/srv/app/perfil.php",
+              local: { size: local.length, mtime: 1700000100 },
+              remote: { size: remote.length, mtime: 1700000000 },
+              status: "localNewer",
+            },
+          ];
+        if (command === "remote_open") return "/snapshot/perfil.php";
+        if (command === "fs_probe") return { size: local.length, binary: false, tooLarge: false };
+        if (command === "fs_read_text") return String(args.path).startsWith("/snapshot/") ? remote : local;
+        if (command === "doc_open") throw new Error("Read-only test fixture");
+        if (command === "languages") return [];
+        if (command === "plugin:window|is_maximized" || command === "plugin:window|is_fullscreen") return false;
+        return null;
+      },
+      { shouldMockEvents: true },
+    );
+    const entry = "/src/main.tsx";
+    await import(/* @vite-ignore */ entry);
+  });
+  const comparison = page.getByRole("region", { name: "Diff Between 'local files' and 'files on Staging'" });
+  await expect(comparison.getByRole("grid", { name: "Files to synchronize" })).toBeVisible();
+  await expect(comparison.getByRole("region", { name: "perfil.php" }).getByRole("textbox")).toHaveCount(2);
+  await expect(page.getByRole("dialog")).toHaveCount(0);
+  await expect(page.getByRole("tree", { name: "Project" })).toHaveCount(0);
+  const frame = await comparison.boundingBox();
+  expect(frame!.y).toBe(0);
+  expect(frame!.height).toBe(page.viewportSize()!.height);
+  await expect(comparison.getByRole("button", { name: "Synchronize All", exact: true })).toBeInViewport();
+  await expect(comparison.getByRole("button", { name: "Synchronize Selected", exact: true })).toBeVisible();
+  await comparison.getByRole("button", { name: "Minimize", exact: true }).click();
+  await comparison.getByRole("button", { name: "Maximize", exact: true }).click();
+  // The caption buttons reach the window API asynchronously.
+  const calls = () => page.evaluate(() => (window as unknown as { deploymentCalls: string[] }).deploymentCalls);
+  await expect.poll(calls).toContain("plugin:window|minimize");
+  await expect.poll(calls).toContain("plugin:window|toggle_maximize");
+  expect(errors).toEqual([]);
+  await page.screenshot({ path: info.outputPath("deployment-native-window.png") });
+});
+
+async function showComparison(page: Page) {
+  await page.evaluate(async () => {
+    const projectModule = "/src/platform/project.ts";
+    const settingsModule = "/src/platform/remoteSettings.ts";
+    const stateModule = "/src/features/deployment/store.ts";
+    const routeModule = "/src/platform/tauriCore.ts";
+    const backendModule = "/src/editor/core/backend.ts";
+    const [{ useProject }, { DEFAULT_DEPLOYMENT_SERVER }, { useDeployment }, { setInvokeRoute }, { docBackend }] =
+      await Promise.all([
+        import(/* @vite-ignore */ projectModule),
+        import(/* @vite-ignore */ settingsModule),
+        import(/* @vite-ignore */ stateModule),
+        import(/* @vite-ignore */ routeModule),
+        import(/* @vite-ignore */ backendModule),
+      ]);
+    const local: Record<string, string> = {
+      "app.js": "export const version = 'local';\n",
+      "perfil.php":
+        "<?php\nclass Perfil extends AppModel {\n    var $name = 'Perfil';\n    var $useTable = 'app_perfiles';\n    var $displayField = 'descripcion';\n\n    function getPerfilesValidos($model) {\n        return $this->find('list', [\n            'fields' => [$this->alias . '.id', $this->alias . '.descripcion'],\n            'order' => $this->alias . '.descripcion ASC',\n        ]);\n    }\n}\n",
+      "hidden.php": "alpha",
+      "same.js": "same",
+    };
+    const remote: Record<string, string> = {
+      "app.js": "export const version = 'deployed';\n",
+      "perfil.php":
+        "<?php\nclass Perfil extends AppModel {\n    var $name = 'Perfil';\n    var $useTable = 'app_perfiles';\n}\n",
+      "hidden.php": "bravo",
+      "same.js": "same",
+    };
+    const root = useProject.getState().project.root;
+    for (const [path, content] of Object.entries(local)) docBackend().files.set(`${root}/${path}`, content);
+    const writes: string[] = [];
+    (window as unknown as { deploymentWrites: string[] }).deploymentWrites = writes;
+    const syncState = { enabled: false, transfers: [] as { path: string; action: string }[][] };
+    (window as unknown as { deploymentSyncState: typeof syncState }).deploymentSyncState = syncState;
+    const text = (path: string) => (path.startsWith("/snapshot/") ? remote : local)[path.split("/").at(-1)!] ?? "";
+    setInvokeRoute((command: string, args: Record<string, unknown>) => {
+      const path = String(args?.path ?? "");
+      if (command === "remote_open") return Promise.resolve(`/snapshot/${path.split("/").at(-1)}`);
+      if (command === "fs_probe") return Promise.resolve({ size: text(path).length, binary: false, tooLarge: false });
+      if (command === "fs_read_text") return Promise.resolve(text(path));
+      if (command === "fs_read_range") {
+        const content = text(path);
+        return Promise.resolve({
+          total: content.length,
+          offset: args.offset,
+          data: btoa(content.slice(Number(args.offset), Number(args.offset) + Number(args.len))),
+        });
+      }
+      if (command === "doc_open") return Promise.reject(new Error("No live document in this fixture"));
+      if (command === "deploy_sync" && syncState.enabled) {
+        const steps = args.steps as { path: string; action: string }[];
+        syncState.transfers.push(steps.map((step) => ({ ...step })));
+        writes.push(command);
+        for (const step of steps) {
+          if (step.action === "upload") remote[step.path] = local[step.path]!;
+          else if (step.action === "download") local[step.path] = remote[step.path]!;
+          else if (step.action === "deleteLocal") delete local[step.path];
+          else if (step.action === "deleteRemote") delete remote[step.path];
+        }
+        return Promise.resolve({ files: steps.length, skipped: 0, errors: [] });
+      }
+      if (command === "deploy_compare") {
+        const name = path.slice(root.length + 1);
+        if (local[name] === undefined && remote[name] === undefined) return Promise.resolve([]);
+        const identical = local[name] === remote[name];
+        return Promise.resolve([
+          {
+            path: name,
+            remotePath: `/srv/app/${name}`,
+            local: local[name] === undefined ? null : { size: local[name]!.length, mtime: 1_700_000_100 },
+            remote:
+              remote[name] === undefined
+                ? null
+                : { size: remote[name]!.length, mtime: identical ? 1_700_000_100 : 1_700_000_000 },
+            status:
+              local[name] === undefined
+                ? "remoteOnly"
+                : remote[name] === undefined
+                  ? "localOnly"
+                  : identical
+                    ? "same"
+                    : "localNewer",
+          },
+        ]);
+      }
+      if (/deploy_(upload|download|sync|delete)|doc_save|fs_write/.test(command)) {
+        writes.push(command);
+        return Promise.reject(new Error("Unexpected write"));
+      }
+      return null;
+    });
+    const entries = Object.keys(local).map((path) => ({
+      path,
+      remotePath: `/srv/app/${path}`,
+      local: { size: local[path]!.length, mtime: 1_700_000_100 },
+      remote: { size: remote[path]!.length, mtime: 1_700_000_000 },
+      status: path === "hidden.php" || path === "same.js" ? "same" : "localNewer",
+    }));
+    useProject.setState({
+      settings: {
+        ...useProject.getState().settings,
+        appearance: { ...useProject.getState().settings?.appearance, theme: "dark", syncWithOs: false },
+        deployment: {
+          servers: [
+            { ...DEFAULT_DEPLOYMENT_SERVER, id: "staging", kind: "local", name: "Staging", rootPath: "/srv/app" },
+          ],
+        },
+      },
+    });
+    useDeployment.setState({
+      sync: {
+        server: "staging",
+        serverName: "Staging",
+        paths: [useProject.getState().project.root],
+        entries,
+        skipped: [],
+        request: null,
+        error: null,
+        choices: Object.fromEntries(entries.map((entry) => [entry.path, entry.status === "same" ? "skip" : "upload"])),
+        hideSame: true,
+        running: false,
+      },
+    });
+  });
+}
+
+test("deployment shows mirrored lists and a selectable side-by-side content diff", async ({
+  workbench: page,
+}, info) => {
+  await showComparison(page);
+  const dialog = page.getByRole("dialog", { name: "Diff Between 'local files' and 'files on Staging'" });
+  await expect(dialog).toBeVisible();
+  const grid = dialog.getByRole("grid", { name: "Files to synchronize" });
+  await grid.getByRole("combobox", { name: "Action perfil.php" }).locator("..", {}).locator("..").click();
+  const preview = dialog.locator('[aria-label="Deployment content comparison"]');
+  await expect(preview.locator(".cm-editor")).toHaveCount(2);
+  await expect(preview.locator(".cm-editor").first()).toContainText("getPerfilesValidos");
+  await expect(preview.locator(".cm-editor").last()).not.toContainText("getPerfilesValidos");
+  await expect(preview.locator(".cm-editor").last().locator(".cm-content")).toHaveAttribute("contenteditable", "false");
+  await expect(dialog.getByRole("toolbar", { name: "Diff" })).toBeVisible();
+  await expect(dialog.getByRole("separator", { name: "Resize file list and diff preview" })).toBeVisible();
+  await dialog.screenshot({ path: info.outputPath("deployment-comparison.png"), animations: "disabled" });
+  await page.getByLabel("Action perfil.php", { exact: true }).selectOption("skip");
+  await grid.focus();
+  await page.keyboard.press("Enter");
+  await expect(dialog).toBeVisible();
+  expect(await page.evaluate(() => (window as unknown as { deploymentWrites: string[] }).deploymentWrites)).toEqual([]);
+});
+
+test("Synchronize Selected and Enter transfer one file at a time while the comparison stays open", async ({
+  workbench: page,
+}) => {
+  await showComparison(page);
+  await page.evaluate(() => {
+    (window as unknown as { deploymentSyncState: { enabled: boolean } }).deploymentSyncState.enabled = true;
+  });
+  const dialog = page.getByRole("dialog", { name: "Diff Between 'local files' and 'files on Staging'" });
+  const grid = dialog.getByRole("grid", { name: "Files to synchronize" });
+  await grid.getByRole("combobox", { name: "Action perfil.php" }).locator("..").locator("..").click();
+  await dialog.getByRole("button", { name: "Synchronize Selected", exact: true }).click();
+  await expect(dialog).toBeVisible();
+  await expect(grid.getByRole("combobox", { name: "Action perfil.php" })).toHaveCount(0);
+  await expect(grid.getByRole("combobox", { name: "Action app.js" })).toHaveValue("upload");
+  await expect(dialog.locator('[aria-label="Deployment content comparison"] .cm-editor').last()).toContainText(
+    "deployed",
+  );
+  await grid.focus();
+  await page.keyboard.press("Enter");
+  await expect(dialog.getByRole("button", { name: "Synchronize All", exact: true })).toBeDisabled();
+  await expect(dialog.getByRole("button", { name: "Synchronize Selected", exact: true })).toBeDisabled();
+  await expect(dialog).toBeVisible();
+  expect(
+    await page.evaluate(
+      () => (window as unknown as { deploymentSyncState: { transfers: unknown[] } }).deploymentSyncState.transfers,
+    ),
+  ).toEqual([[{ path: "perfil.php", action: "upload" }], [{ path: "app.js", action: "upload" }]]);
+});
+
+test("binary content finds changes hidden by metadata and file filters keep the preview in sync", async ({
+  workbench: page,
+}) => {
+  await showComparison(page);
+  await page.getByLabel("Compare by", { exact: true }).selectOption("content");
+  await expect(page.getByLabel("Action hidden.php", { exact: true })).toHaveValue("upload");
+  await expect(page.getByLabel("Action same.js", { exact: true })).toHaveCount(0);
+  await page.getByLabel("Filter by name", { exact: true }).fill("hidden.php");
+  const preview = page.locator('[aria-label="Deployment content comparison"]');
+  await expect(preview.locator(".cm-editor").first()).toContainText("alpha");
+  await expect(preview.locator(".cm-editor").last()).toContainText("bravo");
+  await page.getByLabel("Action hidden.php", { exact: true }).selectOption("skip");
+  expect(await page.evaluate(() => (window as unknown as { deploymentWrites: string[] }).deploymentWrites)).toEqual([]);
+});
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index d75c7fd77..86277d7c1 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -2,10 +2,11 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "Capability for the main window",
-  "windows": ["main", "project-*", "settings-*", "comparison-*"],
+  "windows": ["main", "project-*", "settings-*", "comparison-*", "deployment-*"],
   "permissions": [
     "core:default",
     "core:window:allow-start-dragging",
+    "core:window:allow-start-resize-dragging",
     "core:window:allow-minimize",
     "core:window:allow-toggle-maximize",
     "core:window:allow-internal-toggle-maximize",
diff --git a/src-tauri/capabilities/e2e.json b/src-tauri/capabilities/e2e.json
index 10e5dea30..253b1ce6e 100644
--- a/src-tauri/capabilities/e2e.json
+++ b/src-tauri/capabilities/e2e.json
@@ -2,6 +2,6 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "e2e-bridge",
   "description": "Debug-only automation bridge",
-  "windows": ["main", "project-*", "settings-*", "comparison-*"],
+  "windows": ["main", "project-*", "settings-*", "comparison-*", "deployment-*"],
   "permissions": ["mcp-bridge:default"]
 }
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index d2fba7d5f..a9fd89c3e 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -384,6 +384,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
         window::window_new,
         window::window_open_settings,
         window::window_open_comparison,
+        window::window_open_deployment,
         window::window_cycle,
         window::window_toggle_fullscreen,
         window::window_set_titlebar_height,
diff --git a/src-tauri/src/commands/window.rs b/src-tauri/src/commands/window.rs
index 7c4abb1c7..1716669d3 100644
--- a/src-tauri/src/commands/window.rs
+++ b/src-tauri/src/commands/window.rs
@@ -100,6 +100,20 @@ pub async fn window_open_comparison(
     windows::open_comparison_window(&app, &window, comparison, background)
 }
 
+/// Opens this window's Sync with Deployed window comparing `paths` with `server` (or hands them
+/// to the open one). `background` (`#rrggbb`) paints a new window until its page has loaded.
+#[tauri::command]
+#[specta::specta]
+pub async fn window_open_deployment(
+    app: AppHandle,
+    window: WebviewWindow,
+    server: String,
+    paths: Vec<PathBuf>,
+    background: Option<String>,
+) -> IdeResult<()> {
+    windows::open_deployment_window(&app, &window, server, paths, background)
+}
+
 /// Focuses the next / previous window (⌘` / ⇧⌘`).
 #[tauri::command]
 #[specta::specta]
diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rs
index 871b81daa..c0483b128 100644
--- a/src-tauri/src/windows.rs
+++ b/src-tauri/src/windows.rs
@@ -6,7 +6,7 @@
 //! (`window_take_launch`), and re-taken whenever [`LAUNCH_EVENT`] fires (a
 //! second app instance asking an already-loaded window to open a path).
 //!
-//! Auxiliary windows ([`AuxKind`]: Settings, Compare with Local) belong to a project window and share its project (see
+//! Auxiliary windows ([`AuxKind`]: Settings, Compare with Local, Sync with Deployed) belong to a project window and share its project (see
 //! [`AppState::project`]). Their labels name the kind and the parent
 //! (`settings-main`, `comparison-project-2-3`); their [`Launch`] says what to show.
 
@@ -32,6 +32,8 @@ const SETTINGS_SIZE: (f64, f64) = (980.0, 720.0);
 const SETTINGS_MIN_SIZE: (f64, f64) = (640.0, 420.0);
 const COMPARISON_SIZE: (f64, f64) = (1100.0, 720.0);
 const COMPARISON_MIN_SIZE: (f64, f64) = (640.0, 360.0);
+const DEPLOYMENT_SIZE: (f64, f64) = (1400.0, 900.0);
+const DEPLOYMENT_MIN_SIZE: (f64, f64) = (800.0, 500.0);
 
 /// What a freshly opened window should do once its frontend is up.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -54,6 +56,17 @@ pub struct Launch {
     /// Comparison windows: the revisions to compare (boxed: most launches have none).
     #[serde(default)]
     pub comparison: Option<Box<ComparisonLaunch>>,
+    /// Deployment windows: the server and local selection to compare.
+    #[serde(default)]
+    pub deployment: Option<DeploymentLaunch>,
+}
+
+/// Local files to compare with a deployment server (Sync with Deployed).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
+pub struct DeploymentLaunch {
+    /// Deployment server id.
+    pub server: String,
+    pub paths: Vec<ide_core::IpcPath>,
 }
 
 /// A Git revision and how the comparison window names it.
@@ -193,16 +206,18 @@ impl WindowsState {
 pub enum AuxKind {
     Settings,
     Comparison,
+    Deployment,
 }
 
 impl AuxKind {
-    const ALL: [AuxKind; 2] = [AuxKind::Settings, AuxKind::Comparison];
+    const ALL: [AuxKind; 3] = [AuxKind::Settings, AuxKind::Comparison, AuxKind::Deployment];
 
     /// Label prefix, and the key of the one remembered geometry shared by every window of the kind.
     pub fn name(self) -> &'static str {
         match self {
             AuxKind::Settings => "settings",
             AuxKind::Comparison => "comparison",
+            AuxKind::Deployment => "deployment",
         }
     }
 
@@ -1070,6 +1085,30 @@ pub fn open_comparison_window(
     )
 }
 
+/// Opens (or focuses and hands over to) the project window's Sync with Deployed window: local
+/// files next to their copies on a deployment server, like IDEA's.
+pub fn open_deployment_window(
+    app: &AppHandle,
+    parent: &WebviewWindow,
+    server: String,
+    paths: Vec<PathBuf>,
+    background: Option<String>,
+) -> IdeResult<()> {
+    let paths = paths.into_iter().map(Into::into).collect();
+    open_auxiliary_window(
+        app,
+        parent,
+        AuxWindow {
+            kind: AuxKind::Deployment,
+            title: "Sync with Deployed",
+            size: DEPLOYMENT_SIZE,
+            min_size: DEPLOYMENT_MIN_SIZE,
+            launch: Launch { deployment: Some(DeploymentLaunch { server, paths }), ..Default::default() },
+            background,
+        },
+    )
+}
+
 /// Fit outer bounds, including native decorations, using one monitor's logical coordinate space.
 #[cfg(target_os = "macos")]
 fn fit_over_parent(window: &WebviewWindow, parent: &WebviewWindow, min_size: (f64, f64)) -> tauri::Result<()> {
@@ -1504,12 +1543,13 @@ mod tests {
         assert_eq!(settings_label("project-2"), "settings-project-2");
         assert_eq!(auxiliary("settings-main"), Some((AuxKind::Settings, "main")));
         assert_eq!(auxiliary("comparison-project-2-14"), Some((AuxKind::Comparison, "project-2")));
+        assert_eq!(auxiliary("deployment-project-2"), Some((AuxKind::Deployment, "project-2")));
         for label in ["main", "project-1", "comparison-main", "comparison-main-x", "settings-", "settingsmain"] {
             assert_eq!(auxiliary(label), None, "{label}");
         }
         assert_eq!(state_key("comparison-main-3"), "comparison");
         assert_eq!(state_key("project-3"), "project-3");
-        let labels = ["comparison-main-0", "project-2", "main", "settings-main", "comparison-project-2-1"];
+        let labels = ["comparison-main-0", "project-2", "main", "settings-main", "deployment-project-2"];
         assert_eq!(sorted_labels(labels.into_iter().filter(|l| auxiliary_parent(l).is_none())), ["main", "project-2"]);
     }
 
diff --git a/src/bindings.ts b/src/bindings.ts
index 9a4339428..a88a23b1e 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -774,6 +774,11 @@ export const commands = {
 	 *  `background` (`#rrggbb`) paints it until its page has loaded.
 	 */
 	windowOpenComparison: (comparison: ComparisonLaunch, background: string | null) => typedError<null, IdeError>(__TAURI_INVOKE("window_open_comparison", { comparison, background })),
+	/**
+	 *  Opens this window's Sync with Deployed window comparing `paths` with `server` (or hands them
+	 *  to the open one). `background` (`#rrggbb`) paints a new window until its page has loaded.
+	 */
+	windowOpenDeployment: (server: string, paths: string[], background: string | null) => typedError<null, IdeError>(__TAURI_INVOKE("window_open_deployment", { server, paths, background })),
 	/**  Focuses the next / previous window (⌘` / ⇧⌘`). */
 	windowCycle: (forward: boolean) => __TAURI_INVOKE<void>("window_cycle", { forward }),
 	windowToggleFullscreen: () => typedError<boolean, IdeError>(__TAURI_INVOKE("window_toggle_fullscreen")),
@@ -798,6 +803,8 @@ export const commands = {
 	positions?: FilePosition[],
 	/**  Comparison windows: the revisions to compare (boxed: most launches have none). */
 	comparison?: ComparisonLaunch | null,
+	/**  Deployment windows: the server and local selection to compare. */
+	deployment?: DeploymentLaunch | null,
 } | null>("window_take_launch"),
 	windowCloseContext: () => __TAURI_INVOKE<CloseContext>("window_close_context"),
 	/**  Projects open in project windows, in window order (title bar project widget). */
@@ -2728,6 +2735,13 @@ export type DeploymentCoverage = {
 	skipped: TransferError[],
 };
 
+/**  Local files to compare with a deployment server (Sync with Deployed). */
+export type DeploymentLaunch = {
+	/**  Deployment server id. */
+	server: string,
+	paths: IpcPath[],
+};
+
 export type DeploymentMapping = {
 	/**  Project-relative folder, or absolute inside the project; empty = the project root. */
 	local?: string,
@@ -4491,6 +4505,8 @@ export type Launch = {
 	positions?: FilePosition[],
 	/**  Comparison windows: the revisions to compare (boxed: most launches have none). */
 	comparison?: ComparisonLaunch | null,
+	/**  Deployment windows: the server and local selection to compare. */
+	deployment?: DeploymentLaunch | null,
 };
 
 export type LaunchConfig = {
diff --git a/src/editor/core/embeddedDocuments.test.ts b/src/editor/core/embeddedDocuments.test.ts
new file mode 100644
index 000000000..23bc57e80
--- /dev/null
+++ b/src/editor/core/embeddedDocuments.test.ts
@@ -0,0 +1,46 @@
+import { afterEach, expect, it, vi } from "vitest";
+import { EditorView } from "@codemirror/view";
+import { attachDocument } from "@/editor/api";
+import { useProject } from "@/platform/project";
+import { _resetLanguages } from "./cm/languages";
+import { ipcBackend, type MemoryBackend } from "./backend";
+import { activateEmbeddedDocuments } from "./embeddedDocuments";
+
+vi.mock("./backend", async (original) => {
+  const module = await original<typeof import("./backend")>();
+  return { ...module, ipcBackend: module.createMemoryBackend({ "/p/a.txt": "original\n", "/p/b.txt": "other\n" }) };
+});
+
+afterEach(() => useProject.setState({ settings: null }));
+
+it("retains local changes when another comparison row is selected and saves before releasing document references", async () => {
+  _resetLanguages();
+  useProject.setState({ settings: { files: { autoSave: false } } as never });
+  const documents = activateEmbeddedDocuments();
+  const backend = ipcBackend as MemoryBackend;
+  const first = await attachDocument("/p/a.txt");
+  const view = new EditorView({ doc: first.text(), extensions: [first.extension] });
+  try {
+    view.dispatch({ changes: { from: 0, insert: "changed " } });
+    view.destroy();
+    first.release();
+    const second = await attachDocument("/p/b.txt");
+    const otherView = new EditorView({ doc: second.text(), extensions: [second.extension] });
+    otherView.dispatch({ changes: { from: 0, insert: "pending " } });
+    otherView.destroy();
+    second.release();
+    expect(documents.dirty()).toBe(true);
+    expect(backend.files.get("/p/a.txt")).toBe("original\n");
+    expect(backend.docs.size).toBe(2);
+    await documents.savePaths(["/p/a.txt"]);
+    expect(backend.files.get("/p/a.txt")).toBe("changed original\n");
+    expect(backend.files.get("/p/b.txt")).toBe("other\n");
+    expect(documents.dirty()).toBe(true);
+    await documents.save();
+    expect(backend.files.get("/p/b.txt")).toBe("pending other\n");
+    expect(documents.dirty()).toBe(false);
+  } finally {
+    await documents.dispose();
+  }
+  expect(backend.docs.size).toBe(0);
+});
diff --git a/src/editor/core/embeddedDocuments.ts b/src/editor/core/embeddedDocuments.ts
new file mode 100644
index 000000000..eaebc4516
--- /dev/null
+++ b/src/editor/core/embeddedDocuments.ts
@@ -0,0 +1,49 @@
+/** Live document services for a native comparison window, without editor tabs or session restoration. */
+import { _provideCodePreview, _provideDocumentAttacher } from "@/editor/api";
+import { useProject } from "@/platform/project";
+import { notifications } from "@/workbench/contributions";
+import { ipcBackend } from "./backend";
+import { previewExtensions } from "./cm/preview";
+import { installColorScheme } from "./colorSchemeRuntime";
+import { attachDocument } from "./model/attachment";
+import { DocumentManager, type DocModel } from "./model/document";
+
+class EmbeddedDocumentManager extends DocumentManager {
+  // Keep files visited in this comparison until it closes, including unsaved
+  // edits in a row that is no longer selected. No project tab/session is made.
+  override release(_model: DocModel) {}
+}
+
+export function activateEmbeddedDocuments() {
+  const manager = new EmbeddedDocumentManager(ipcBackend, {
+    settings: () => useProject.getState().settings,
+    notify: (message) => notifications().notify(message),
+  });
+  manager.start();
+  _provideDocumentAttacher((path) => attachDocument(manager, path));
+  _provideCodePreview((path) => previewExtensions(path, useProject.getState().settings?.editor, ipcBackend));
+  const offColor = installColorScheme();
+  const offSettings = useProject.subscribe((s, prev) => {
+    if (s.settings !== prev.settings) manager.applySettings();
+  });
+  return {
+    dirty: () => [...manager.byPath.values()].some((model) => model.getMeta().dirty),
+    save: () => manager.saveAll("explicit"),
+    savePaths: (paths: readonly string[]) =>
+      Promise.all(paths.map((path) => manager.get(path)?.save("explicit"))).then(() => {}),
+    async dispose() {
+      _provideDocumentAttacher(null);
+      _provideCodePreview(null);
+      offSettings();
+      offColor();
+      manager.stop();
+      for (const model of manager.byPath.values()) {
+        await model.sync.whenIdle();
+        model.dispose();
+        await ipcBackend.close(model.doc);
+      }
+      manager.byPath.clear();
+      manager.byId.clear();
+    },
+  };
+}
diff --git a/src/features/deployment/Deployment.module.css b/src/features/deployment/Deployment.module.css
index 6b52c57cc..42be83c72 100644
--- a/src/features/deployment/Deployment.module.css
+++ b/src/features/deployment/Deployment.module.css
@@ -80,21 +80,136 @@
 }
 
 /* Sync dialog */
+.nativeWindow {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-width: 0;
+  overflow: hidden;
+  background: var(--bg-dialog, var(--bg-elev));
+  color: var(--fg);
+}
+.nativeBody {
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+}
+.nativeFooter {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 16px;
+  flex: none;
+}
+.syncWindow {
+  height: calc(100vh - 48px);
+}
+.syncWindow [data-dialog-body] {
+  overflow: hidden;
+}
 .sync {
   display: flex;
   flex-direction: column;
   gap: 8px;
-  min-height: 360px;
+  height: 100%;
+  min-height: 0;
+  padding: 8px 10px 0;
+}
+.comparisonToolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  flex: none;
+  gap: 4px;
+}
+.separator {
+  height: 20px;
+  border-left: 1px solid var(--border);
+  margin: 0 5px;
+}
+.filterButton {
+  width: 28px;
+  height: 26px;
+  padding: 0;
+  border: 1px solid transparent;
+  border-radius: var(--radius-control, 4px);
+  color: var(--fg-muted);
+  background: transparent;
+  font-size: 19px;
+  cursor: pointer;
+}
+.filterButton[aria-pressed="true"] {
+  background: var(--bg-tree-hover);
+  border-color: var(--border);
+  color: var(--accent);
+}
+.filterButton:focus-visible {
+  outline: 2px solid var(--focus-ring);
+}
+.compareBy,
+.fileFilter {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  white-space: nowrap;
+}
+.compareBy select {
+  height: 26px;
+  color: var(--fg);
+  background: var(--bg-input, var(--bg-island));
+  border: 1px solid var(--border);
+  border-radius: var(--radius-control, 4px);
+  font: inherit;
+}
+.fileFilter {
+  margin-left: auto;
+  width: clamp(180px, 30%, 480px);
+}
+.fileFilter > input {
+  width: 100%;
+  min-width: 0;
+}
+.comparisonRoots {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 18px;
+  flex: none;
+}
+.comparisonRoots > span {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-control, 4px);
+  padding: 5px 8px;
+}
+.comparisonRoots > span > span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.comparisonSplit {
+  flex: 1;
+  min-height: 0;
+}
+.fileList {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
 }
 .syncTableHost {
   flex: 1;
-  max-height: 460px;
+  min-height: 0;
   overflow: auto;
   border: 1px solid var(--border);
   border-radius: var(--radius-control, 4px);
 }
 .syncTable {
   width: 100%;
+  min-width: 900px;
   border-collapse: collapse;
   table-layout: fixed;
 }
@@ -123,17 +238,28 @@
 .syncTable tbody tr:hover {
   background: var(--bg-tree-hover);
 }
-.choiceCol {
-  width: 128px;
+.syncTable tbody tr[aria-selected="true"] {
+  background: var(--bg-tree-selected, var(--accent-soft));
+}
+.fileName {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.operationCol {
+  width: 108px;
+}
+.operationCell {
+  border-left: 1px solid var(--border);
+  border-right: 1px solid var(--border);
 }
 .sizeCol {
   width: 80px;
 }
 .timeCol {
-  width: 128px;
-}
-.statusCol {
-  width: 112px;
+  width: 148px;
 }
 .num {
   text-align: right;
@@ -169,6 +295,28 @@
 .status-same {
   color: var(--fg-subtle);
 }
+.listHint {
+  flex: none;
+  color: var(--fg-subtle);
+  font-size: var(--fs-small);
+  padding: 3px 6px;
+  text-align: right;
+}
+.preview {
+  height: 100%;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  border: 1px solid var(--border);
+}
+.previewMessage {
+  padding: 18px;
+  display: flex;
+  align-items: flex-start;
+  flex-direction: column;
+  gap: 12px;
+}
 
 /* SSH password prompt */
 .secret {
diff --git a/src/features/deployment/Dialogs.test.tsx b/src/features/deployment/Dialogs.test.tsx
index 15ce23198..372e6eb73 100644
--- a/src/features/deployment/Dialogs.test.tsx
+++ b/src/features/deployment/Dialogs.test.tsx
@@ -1,18 +1,27 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import type { SyncEntry } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { DEFAULT_DEPLOYMENT_SERVER } from "@/platform/remoteSettings";
+
+const mocks = vi.hoisted(() => ({ equal: vi.fn(), sync: vi.fn(), refresh: vi.fn() }));
+vi.mock("./comparison", () => ({ createDeploymentComparison: () => ({ equal: mocks.equal, preview: vi.fn() }) }));
+vi.mock("./SyncPreview", () => ({
+  SyncPreview: ({ entry }: { entry: SyncEntry | null }) => <div data-testid="preview">{entry?.remotePath}</div>,
+}));
+vi.mock("./actions", () => ({ closeSync: vi.fn(), runSync: mocks.sync, openSync: mocks.refresh }));
 import { DeploymentDialogs } from "./Dialogs";
 import { initialSyncChoices } from "./model";
 import { useDeployment } from "./store";
+import { SyncDialog } from "./SyncDialog";
 
 const entry = (path: string, status: SyncEntry["status"]): SyncEntry => ({
   path,
   remotePath: `/srv/app/${path}`,
   local: status === "remoteOnly" ? null : { size: 2048, mtime: 1_700_000_000 },
-  remote: status === "localOnly" ? null : { size: 10, mtime: 1_700_000_100 },
+  remote: status === "localOnly" ? null : { size: 2048, mtime: 1_700_000_100 },
   status,
 });
-
 function openSync(entries: SyncEntry[]) {
   useDeployment.setState({
     sync: {
@@ -29,31 +38,132 @@ function openSync(entries: SyncEntry[]) {
     },
   });
 }
-
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.equal.mockResolvedValue(false);
+  useProject.setState({
+    project: { root: "/work/app" } as never,
+    settings: {
+      deployment: { servers: [{ ...DEFAULT_DEPLOYMENT_SERVER, id: "s1", name: "Staging" }] },
+    } as never,
+  });
+});
 afterEach(() => {
   cleanup();
   useDeployment.setState({ sync: null });
 });
+const table = () => screen.getByRole("grid", { name: "Files to synchronize" });
+const row = (path: string) =>
+  within(table())
+    .getByRole("combobox", { name: `Action ${path}` })
+    .closest("tr")!;
 
-describe("Sync dialog", () => {
-  it("lists the differing files with their default actions and hides identical ones", () => {
+describe("deployment directory and content comparison", () => {
+  it("fills a secondary window without creating an in-page modal and saves local edits before synchronization", async () => {
+    let saved!: () => void;
+    const beforeSynchronize = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          saved = resolve;
+        }),
+    );
+    openSync([entry("a.php", "localOnly")]);
+    render(<SyncDialog standalone beforeSynchronize={beforeSynchronize} />);
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(screen.getByRole("region", { name: "Diff Between 'local files' and 'files on Staging'" })).toContainElement(
+      table(),
+    );
+    fireEvent.click(screen.getByRole("button", { name: "Synchronize All" }));
+    expect(screen.getByRole("button", { name: "Synchronize All" })).toBeDisabled();
+    expect(mocks.sync).not.toHaveBeenCalled();
+    await act(async () => saved());
+    expect(mocks.sync).toHaveBeenCalledWith([{ path: "a.php", action: "upload" }]);
+  });
+  it("shows mirrored metadata and previews the selected file, with identical rows filtered", () => {
     openSync([entry("a.php", "localOnly"), entry("b.php", "remoteNewer"), entry("c.php", "same")]);
     render(<DeploymentDialogs />);
-    expect(screen.getByText("a.php")).toBeTruthy();
-    expect(screen.queryByText("c.php")).toBeNull();
-    expect((screen.getByLabelText("Action a.php") as HTMLSelectElement).value).toBe("upload");
-    expect((screen.getByLabelText("Action b.php") as HTMLSelectElement).value).toBe("download");
-
-    fireEvent.click(screen.getByLabelText(/Hide identical files/));
-    expect(screen.getByText("c.php")).toBeTruthy();
-    expect((screen.getByLabelText("Action c.php") as HTMLSelectElement).value).toBe("skip");
+    expect(within(table()).getByRole("columnheader", { name: "Local name" })).toBeInTheDocument();
+    expect(within(table()).getByRole("columnheader", { name: "Remote name" })).toBeInTheDocument();
+    expect(screen.queryByRole("combobox", { name: "Action c.php" })).not.toBeInTheDocument();
+    expect(screen.getByTestId("preview")).toHaveTextContent("/srv/app/a.php");
+    fireEvent.click(row("b.php"));
+    expect(row("b.php")).toHaveAttribute("aria-selected", "true");
+    expect(screen.getByTestId("preview")).toHaveTextContent("/srv/app/b.php");
+    fireEvent.click(screen.getByRole("button", { name: "Show identical files" }));
+    expect(screen.getByRole("combobox", { name: "Action c.php" })).toHaveValue("skip");
   });
-
-  it("updates the choice of a row", () => {
+  it("filters by name and category, navigates with arrows and cycles operations with Space", () => {
+    openSync([entry("a.php", "localOnly"), entry("b.php", "remoteNewer")]);
+    render(<DeploymentDialogs />);
+    fireEvent.keyDown(table(), { key: "ArrowDown" });
+    expect(row("b.php")).toHaveAttribute("aria-selected", "true");
+    fireEvent.keyDown(table(), { key: " " });
+    expect(screen.getByRole("combobox", { name: "Action b.php" })).toHaveValue("deleteRemote");
+    fireEvent.keyDown(screen.getByLabelText("Filter by name"), { key: "Enter" });
+    expect(mocks.sync).not.toHaveBeenCalled();
+    fireEvent.change(screen.getByLabelText("Filter by name"), { target: { value: "b.php" } });
+    expect(screen.queryByRole("combobox", { name: "Action a.php" })).not.toBeInTheDocument();
+    fireEvent.click(screen.getByRole("button", { name: "Show different files" }));
+    expect(screen.getByText("No matching differences")).toBeInTheDocument();
+  });
+  it("updates a row's operation and only applies explicit synchronization", () => {
     openSync([entry("a.php", "localOnly")]);
     render(<DeploymentDialogs />);
     fireEvent.change(screen.getByLabelText("Action a.php"), { target: { value: "skip" } });
+    expect(screen.getByRole("button", { name: "Synchronize All" })).toBeDisabled();
+    fireEvent.change(screen.getByLabelText("Action a.php"), { target: { value: "upload" } });
+    fireEvent.click(screen.getByRole("button", { name: "Synchronize All" }));
+    expect(mocks.sync).toHaveBeenCalledWith([{ path: "a.php", action: "upload" }]);
+  });
+  it("finds content hidden by identical metadata and skips byte-identical files", async () => {
+    mocks.equal.mockImplementation(async (e: SyncEntry) => e.path === "a.php");
+    openSync([entry("a.php", "localNewer"), entry("b.php", "same")]);
+    render(<DeploymentDialogs />);
+    fireEvent.change(screen.getByLabelText("Compare by"), { target: { value: "content" } });
+    await waitFor(() => expect(screen.getByLabelText("Action b.php")).toHaveValue("upload"));
+    expect(screen.queryByLabelText("Action a.php")).not.toBeInTheDocument();
     expect(useDeployment.getState().sync?.choices["a.php"]).toBe("skip");
-    expect((screen.getByRole("button", { name: "Synchronize" }) as HTMLButtonElement).disabled).toBe(true);
+    expect(mocks.equal).toHaveBeenCalledTimes(2);
+    fireEvent.change(screen.getByLabelText("Compare by"), { target: { value: "metadata" } });
+    expect(screen.getByLabelText("Action a.php")).toHaveValue("upload");
+  });
+  it("synchronizes only the current row from the toolbar or Enter, and disables skipped selections", async () => {
+    openSync([entry("a.php", "localOnly"), entry("b.php", "remoteNewer")]);
+    render(<DeploymentDialogs />);
+    fireEvent.click(row("b.php"));
+    fireEvent.click(screen.getByRole("button", { name: "Synchronize Selected" }));
+    expect(mocks.sync).toHaveBeenCalledWith([{ path: "b.php", action: "download" }], "selected");
+    await act(async () => {});
+    mocks.sync.mockClear();
+    fireEvent.click(row("a.php"));
+    fireEvent.keyDown(table(), { key: "Enter" });
+    expect(mocks.sync).toHaveBeenCalledWith([{ path: "a.php", action: "upload" }], "selected");
+    await act(async () => {});
+    mocks.sync.mockClear();
+    fireEvent.change(screen.getByLabelText("Action a.php"), { target: { value: "skip" } });
+    expect(screen.getByRole("button", { name: "Synchronize Selected" })).toBeDisabled();
+    expect(screen.getByRole("button", { name: "Synchronize All" })).toBeEnabled();
+    fireEvent.keyDown(table(), { key: "Enter" });
+    expect(mocks.sync).not.toHaveBeenCalled();
+  });
+  it("preserves manual choices, reports failures, and ignores a cancelled scan", async () => {
+    let finish!: (value: boolean) => void;
+    mocks.equal.mockReturnValueOnce(
+      new Promise<boolean>((resolve) => {
+        finish = resolve;
+      }),
+    );
+    openSync([entry("a.php", "localNewer")]);
+    render(<DeploymentDialogs />);
+    fireEvent.change(screen.getByLabelText("Action a.php"), { target: { value: "skip" } });
+    fireEvent.change(screen.getByLabelText("Compare by"), { target: { value: "content" } });
+    await waitFor(() => expect(mocks.equal).toHaveBeenCalledOnce());
+    fireEvent.click(screen.getByRole("button", { name: "Stop content comparison" }));
+    await act(async () => finish(true));
+    expect(screen.getByLabelText("Action a.php")).toHaveValue("skip");
+    mocks.equal.mockRejectedValueOnce(new Error("Permission denied"));
+    fireEvent.change(screen.getByLabelText("Compare by"), { target: { value: "content" } });
+    expect(await screen.findByRole("alert")).toHaveTextContent("Permission denied");
+    expect(screen.getByLabelText("Action a.php")).toHaveValue("skip");
   });
 });
diff --git a/src/features/deployment/Dialogs.tsx b/src/features/deployment/Dialogs.tsx
index 982a1cda4..a60893de2 100644
--- a/src/features/deployment/Dialogs.tsx
+++ b/src/features/deployment/Dialogs.tsx
@@ -1,173 +1,11 @@
-/** Deployment dialogs: Sync with Deployed and the SSH password prompt. */
+/** Deployment comparison and SSH password prompt. */
 import { useState } from "react";
-import clsx from "clsx";
-import type { SyncEntry, SyncStatus } from "@/platform/ipc";
-import { useTx, useTxTemplate } from "@/platform/i18n";
-import { relativePath, useProject } from "@/platform/project";
-import { Checkbox, Dialog, Input, Spinner, T } from "@/ui";
-import { closeSync, runSync } from "./actions";
-import { formatSize, formatTime, syncChoices, syncSteps, type SyncChoice } from "./model";
-import { patchSync, useDeployment } from "./store";
+import { Checkbox, Dialog, Input } from "@/ui";
+import { useDeployment } from "./store";
+import { SyncDialog } from "./SyncDialog";
 import styles from "./Deployment.module.css";
 
-const STATUS_LABELS: Record<SyncStatus, string> = {
-  localOnly: "Local only",
-  remoteOnly: "Remote only",
-  localNewer: "Local is newer",
-  remoteNewer: "Remote is newer",
-  different: "Different size",
-  same: "Identical",
-};
-
-const CHOICE_LABELS: Record<SyncChoice, string> = {
-  skip: "Skip",
-  upload: "Upload",
-  download: "Download",
-  deleteRemote: "Delete remote",
-  deleteLocal: "Delete local",
-};
-
-function SyncRow({
-  entry,
-  choice,
-  onChoice,
-  disabled,
-}: {
-  entry: SyncEntry;
-  choice: SyncChoice;
-  onChoice: (c: SyncChoice) => void;
-  disabled: boolean;
-}) {
-  const tx = useTx();
-  return (
-    <tr className={clsx(choice === "skip" && styles.skipped)}>
-      <td>
-        <select
-          className={styles.choice}
-          value={choice}
-          disabled={disabled}
-          aria-label={`${tx("Action")} ${entry.path}`}
-          onChange={(e) => onChoice(e.target.value as SyncChoice)}
-        >
-          {syncChoices(entry).map((c) => (
-            <option key={c} value={c}>
-              {tx(CHOICE_LABELS[c])}
-            </option>
-          ))}
-        </select>
-      </td>
-      <td className={styles.mono} title={entry.remotePath}>
-        {entry.path}
-      </td>
-      <td className={styles.num}>{entry.local ? formatSize(entry.local.size) : ""}</td>
-      <td>{formatTime(entry.local?.mtime)}</td>
-      <td className={styles.num}>{entry.remote ? formatSize(entry.remote.size) : ""}</td>
-      <td>{formatTime(entry.remote?.mtime)}</td>
-      <td className={styles[`status-${entry.status}`]}>{tx(STATUS_LABELS[entry.status])}</td>
-    </tr>
-  );
-}
-
-function SyncDialog() {
-  const sync = useDeployment((s) => s.sync);
-  const root = useProject((s) => s.project?.root ?? null);
-  const tx = useTx();
-  const txt = useTxTemplate();
-  if (!sync) return null;
-  const entries = sync.entries;
-  const shown = entries?.filter((e) => !sync.hideSame || e.status !== "same") ?? [];
-  const steps = syncSteps(sync.choices);
-  const same = entries?.filter((e) => e.status === "same").length ?? 0;
-  const where = sync.paths.map((path) => (root ? relativePath(root, path) || "/" : path)).join(", ");
-
-  return (
-    <Dialog
-      open
-      title={txt(`Sync with ${sync.serverName}`)}
-      onClose={closeSync}
-      width={920}
-      footerStart={
-        entries && (
-          <Checkbox
-            checked={sync.hideSame}
-            onChange={(hideSame) => patchSync({ hideSame })}
-            label={txt(`Hide identical files (${same})`)}
-          />
-        )
-      }
-      buttons={[
-        { label: "Cancel", role: "cancel" },
-        {
-          label: "Synchronize",
-          role: "default",
-          disabled: !entries || sync.running || steps.length === 0,
-          onClick: () => void runSync(steps),
-        },
-      ]}
-    >
-      <div className={styles.sync}>
-        <div className={styles.note}>
-          <span className={styles.mono}>{where}</span>
-          {entries && <> · {txt(`${steps.length} of ${entries.length} files will change`)}</>}
-        </div>
-        {!!sync.skipped?.length && (
-          <div className={styles.note}>
-            {txt(`Skipped: ${sync.skipped.length}`)}:{" "}
-            {sync.skipped.map((s) => (root ? relativePath(root, s.path) : s.path)).join(", ")}
-          </div>
-        )}
-        {sync.error && <div className={styles.error}>{sync.error}</div>}
-        {!entries && !sync.error && (
-          <div className={styles.center}>
-            <Spinner /> <T>Comparing local and remote files…</T>
-          </div>
-        )}
-        {entries && (
-          <div className={styles.syncTableHost}>
-            <table className={styles.syncTable} aria-label={tx("Files to synchronize")}>
-              <thead>
-                <tr>
-                  <th className={styles.choiceCol}>{tx("Action")}</th>
-                  <th>{tx("Path")}</th>
-                  <th className={styles.sizeCol}>{tx("Local size")}</th>
-                  <th className={styles.timeCol}>{tx("Local modified")}</th>
-                  <th className={styles.sizeCol}>{tx("Remote size")}</th>
-                  <th className={styles.timeCol}>{tx("Remote modified")}</th>
-                  <th className={styles.statusCol}>{tx("Status")}</th>
-                </tr>
-              </thead>
-              <tbody>
-                {shown.length === 0 && (
-                  <tr>
-                    <td colSpan={7} className={styles.emptyCell}>
-                      <T>Local and remote files are identical</T>
-                    </td>
-                  </tr>
-                )}
-                {shown.map((e) => (
-                  <SyncRow
-                    key={e.path}
-                    entry={e}
-                    choice={sync.choices[e.path] ?? "skip"}
-                    disabled={sync.running}
-                    onChoice={(c) => patchSync({ choices: { ...sync.choices, [e.path]: c } })}
-                  />
-                ))}
-              </tbody>
-            </table>
-          </div>
-        )}
-        {sync.running && (
-          <div className={styles.center}>
-            <Spinner /> <T>Synchronizing…</T>
-          </div>
-        )}
-      </div>
-    </Dialog>
-  );
-}
-
-function SecretDialog() {
+export function SecretDialog() {
   const prompt = useDeployment((s) => s.secret);
   const [secret, setSecret] = useState("");
   const [save, setSave] = useState(false);
diff --git a/src/features/deployment/SyncDialog.tsx b/src/features/deployment/SyncDialog.tsx
new file mode 100644
index 000000000..0d100e5a3
--- /dev/null
+++ b/src/features/deployment/SyncDialog.tsx
@@ -0,0 +1,522 @@
+/** Deployment directory diff: mirrored file lists above an embedded content diff. */
+import { useEffect, useMemo, useRef, useState, type KeyboardEvent, type ReactNode } from "react";
+import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
+import clsx from "clsx";
+import type { SyncEntry, SyncStatus, SyncStep } from "@/platform/ipc";
+import { useTx, useTxTemplate } from "@/platform/i18n";
+import { useProject } from "@/platform/project";
+import { useWorkflowSettings } from "@/platform/workflowSettings";
+import {
+  Dialog,
+  DialogButtons,
+  Icon,
+  IconButton,
+  Input,
+  Spinner,
+  SplitGroup,
+  SplitHandle,
+  SplitPanel,
+  T,
+  fileIconName,
+  type DialogProps,
+} from "@/ui";
+import { TitleBar } from "@/workbench/TitleBar";
+import { usePlatform } from "@/platform/platformInfo";
+import { closeSync, openSync, runSync, type SyncRunMode } from "./actions";
+import { createDeploymentComparison, type DeploymentComparison } from "./comparison";
+import { defaultSyncAction, formatSize, formatTime, syncChoices, syncSteps, type SyncChoice } from "./model";
+import { patchSync, useDeployment, type SyncDialogState } from "./store";
+import { SyncPreview } from "./SyncPreview";
+import styles from "./Deployment.module.css";
+
+const STATUS: Record<SyncStatus, string> = {
+  localOnly: "Local only",
+  remoteOnly: "Remote only",
+  localNewer: "Local is newer",
+  remoteNewer: "Remote is newer",
+  different: "Contents differ",
+  same: "Identical",
+};
+const CHOICES: Record<SyncChoice, [string, string]> = {
+  skip: ["—", "Skip"],
+  upload: ["→", "Upload"],
+  download: ["←", "Download"],
+  deleteRemote: ["× →", "Delete remote"],
+  deleteLocal: ["← ×", "Delete local"],
+};
+type CompareBy = "metadata" | "content";
+const NO_VERIFIED: Record<string, boolean> = {};
+const NO_ERRORS: Record<string, string> = {};
+interface ContentScan {
+  comparison: DeploymentComparison;
+  entries: SyncEntry[];
+  verified: Record<string, boolean>;
+  errors: Record<string, string>;
+  progress: number | null;
+}
+
+function ComparisonFrame({ standalone, ...props }: DialogProps & { standalone: boolean }) {
+  const ownTitleBar = usePlatform((s) => s.overlayTitleBar || s.framelessTitleBar);
+  if (!standalone) return <Dialog {...props} />;
+  return (
+    <section className={styles.nativeWindow} aria-label={typeof props.title === "string" ? props.title : undefined}>
+      {ownTitleBar && <TitleBar minimal title={props.title as string} />}
+      <div className={styles.nativeBody}>{props.children}</div>
+      <footer className={styles.nativeFooter}>
+        {props.footerStart as ReactNode}
+        <DialogButtons buttons={props.buttons ?? []} onCancel={props.onClose} />
+      </footer>
+    </section>
+  );
+}
+
+function SyncComparison({
+  sync,
+  standalone,
+  beforeSynchronize,
+}: {
+  sync: SyncDialogState;
+  standalone: boolean;
+  beforeSynchronize?: (steps: SyncStep[]) => Promise<void>;
+}) {
+  const root = useProject((s) => s.project?.root ?? null);
+  const server = useWorkflowSettings((s) => s.deployment.servers.find((item) => item.id === sync.server));
+  const tx = useTx();
+  const txt = useTxTemplate();
+  const [selectedPath, setSelectedPath] = useState<string | null>(null);
+  const [filter, setFilter] = useState("");
+  const [showLocal, setShowLocal] = useState(true);
+  const [showDifferent, setShowDifferent] = useState(true);
+  const [showRemote, setShowRemote] = useState(true);
+  const [compareBy, setCompareBy] = useState<CompareBy>("metadata");
+  const [scan, setScan] = useState<ContentScan | null>(null);
+  const [generation, setGeneration] = useState(0);
+  const touched = useRef(new Set<string>());
+  const synchronizing = useRef(false);
+  const comparison = useMemo(
+    () => (server && root ? { ...createDeploymentComparison(server, root), generation, entries: sync.entries } : null),
+    [server, root, generation, sync.entries],
+  );
+  const entries = sync.entries;
+  const activeScan =
+    compareBy === "content" && scan?.comparison === comparison && scan.entries === entries ? scan : null;
+  const verified = activeScan?.verified ?? NO_VERIFIED;
+  const checkErrors = activeScan?.errors ?? NO_ERRORS;
+  const progress = compareBy === "content" && entries && comparison ? (activeScan ? activeScan.progress : 0) : null;
+  const changeCompareBy = (mode: CompareBy) => {
+    setScan(null);
+    setCompareBy(mode);
+  };
+
+  useEffect(() => {
+    const abort = new AbortController();
+    if (!entries || !comparison) return;
+    const suggest = (entry: SyncEntry, status: SyncStatus) => {
+      const current = useDeployment.getState().sync;
+      if (current?.entries !== entries || touched.current.has(entry.path)) return;
+      patchSync({ choices: { ...current.choices, [entry.path]: defaultSyncAction(status) } });
+    };
+    if (compareBy === "metadata") {
+      entries.forEach((entry) => suggest(entry, entry.status));
+      return;
+    }
+    void (async () => {
+      await Promise.resolve();
+      const verified: Record<string, boolean> = {};
+      const errors: Record<string, string> = {};
+      for (let i = 0; i < entries.length; i++) {
+        if (abort.signal.aborted) return;
+        const entry = entries[i]!;
+        try {
+          if (entry.local && entry.remote) {
+            const equal = await comparison.equal(entry, abort.signal);
+            if (abort.signal.aborted) return;
+            verified[entry.path] = equal;
+            suggest(entry, equal ? "same" : entry.status === "same" ? "different" : entry.status);
+          }
+        } catch (e) {
+          if (abort.signal.aborted) return;
+          errors[entry.path] = e instanceof Error ? e.message : String(e);
+        }
+        if (abort.signal.aborted) return;
+        setScan({ comparison, entries, verified: { ...verified }, errors: { ...errors }, progress: i + 1 });
+      }
+      if (!abort.signal.aborted) setScan({ comparison, entries, verified, errors, progress: null });
+    })();
+    return () => abort.abort();
+  }, [entries, comparison, compareBy]);
+
+  const compared = useMemo(
+    () =>
+      entries?.map((entry) =>
+        verified[entry.path] === undefined
+          ? entry
+          : {
+              ...entry,
+              status: verified[entry.path] ? ("same" as const) : ("different" as const),
+            },
+      ) ?? [],
+    [entries, verified],
+  );
+  const shown = useMemo(() => {
+    const query = filter.trim().toLocaleLowerCase();
+    return compared.filter(
+      (entry) =>
+        entry.path.toLocaleLowerCase().includes(query) &&
+        (checkErrors[entry.path] ||
+          (entry.status === "same"
+            ? !sync.hideSame
+            : entry.status === "localOnly"
+              ? showLocal
+              : entry.status === "remoteOnly"
+                ? showRemote
+                : showDifferent)),
+    );
+  }, [compared, filter, checkErrors, sync.hideSame, showLocal, showRemote, showDifferent]);
+  const selected = shown.find((entry) => entry.path === selectedPath) ?? shown[0] ?? null;
+  const previewEntry = entries?.find((entry) => entry.path === selected?.path) ?? null;
+  const steps = syncSteps(sync.choices);
+  const selectedSteps = steps.filter((step) => step.path === selected?.path);
+  const busy = sync.running || !entries || progress !== null;
+  const synchronize = async (mode: SyncRunMode) => {
+    const selectedOperations = mode === "selected" ? selectedSteps : steps;
+    if (busy || synchronizing.current || !selectedOperations.length) return;
+    synchronizing.current = true;
+    if (mode === "selected") selectedOperations.forEach((step) => touched.current.add(step.path));
+    try {
+      if (beforeSynchronize) {
+        patchSync({ running: true });
+        await beforeSynchronize(selectedOperations);
+        if (useDeployment.getState().sync?.paths !== sync.paths) return;
+      }
+      const report = await (mode === "selected" ? runSync(selectedOperations, mode) : runSync(selectedOperations));
+      if (mode === "selected" && report?.files && !report.errors.length && !report.skipped) {
+        const index = shown.findIndex((entry) => entry.path === selected?.path);
+        const choices = useDeployment.getState().sync?.choices;
+        const next = [...shown.slice(index + 1), ...shown.slice(0, index)].find(
+          (entry) => choices?.[entry.path] && choices[entry.path] !== "skip",
+        );
+        if (next) setSelectedPath((current) => (current === selectedPath ? next.path : current));
+      }
+    } catch (error) {
+      if (useDeployment.getState().sync?.paths === sync.paths)
+        patchSync({ running: false, error: error instanceof Error ? error.message : String(error) });
+    } finally {
+      synchronizing.current = false;
+    }
+  };
+  const choose = (entry: SyncEntry, choice: SyncChoice) => {
+    if (sync.running) return;
+    touched.current.add(entry.path);
+    setSelectedPath(entry.path);
+    patchSync({ choices: { ...useDeployment.getState().sync?.choices, [entry.path]: choice } });
+  };
+  const onTableKey = (event: KeyboardEvent<HTMLTableElement>) => {
+    if ((event.target as HTMLElement).closest("select, button, input")) return;
+    const index = shown.findIndex((entry) => entry.path === selected?.path);
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      const next = shown[Math.max(0, Math.min(shown.length - 1, index + (event.key === "ArrowDown" ? 1 : -1)))];
+      if (next) {
+        setSelectedPath(next.path);
+        document.getElementById(`deploy-row-${shown.indexOf(next)}`)?.scrollIntoView({ block: "nearest" });
+      }
+    } else if (
+      event.key === "Enter" &&
+      !event.altKey &&
+      !event.ctrlKey &&
+      !event.metaKey &&
+      !event.shiftKey &&
+      !event.nativeEvent.isComposing
+    ) {
+      event.preventDefault();
+      void synchronize("selected");
+    } else if (event.key === " " && selected && !busy) {
+      event.preventDefault();
+      const choices = syncChoices(selected);
+      choose(selected, choices[(choices.indexOf(sync.choices[selected.path] ?? "skip") + 1) % choices.length]!);
+    }
+  };
+  const refresh = () => {
+    if (!server || busy) return;
+    touched.current.clear();
+    setGeneration((n) => n + 1);
+    void openSync(server, sync.paths);
+  };
+
+  return (
+    <ComparisonFrame
+      standalone={standalone}
+      open
+      title={txt(`Diff Between 'local files' and 'files on ${sync.serverName}'`)}
+      onClose={standalone ? () => void getCurrentWebviewWindow().close() : closeSync}
+      width="calc(100vw - 48px)"
+      className={styles.syncWindow}
+      resizable="both"
+      footerStart={
+        <span className={styles.note}>{entries && txt(`${steps.length} of ${entries.length} files will change`)}</span>
+      }
+      buttons={[
+        { label: "Cancel", role: "cancel" },
+        {
+          label: "Synchronize All",
+          role: "extra",
+          disabled: busy || steps.length === 0,
+          onClick: () => void synchronize("all"),
+        },
+      ]}
+    >
+      <div className={styles.sync}>
+        <div className={styles.comparisonToolbar} role="toolbar" aria-label={tx("Deployment comparison options")}>
+          <IconButton
+            icon="refresh"
+            title="Refresh comparison"
+            size="small"
+            disabled={busy || !server}
+            onClick={refresh}
+          />
+          <span className={styles.separator} />
+          <button
+            className={styles.filterButton}
+            aria-label={tx("Show local-only files")}
+            aria-pressed={showLocal}
+            onClick={() => setShowLocal(!showLocal)}
+          >
+            →
+          </button>
+          <button
+            className={styles.filterButton}
+            aria-label={tx("Show different files")}
+            aria-pressed={showDifferent}
+            onClick={() => setShowDifferent(!showDifferent)}
+          >
+            ≠
+          </button>
+          <button
+            className={styles.filterButton}
+            aria-label={tx("Show identical files")}
+            aria-pressed={!sync.hideSame}
+            onClick={() => patchSync({ hideSame: !sync.hideSame })}
+          >
+            =
+          </button>
+          <button
+            className={styles.filterButton}
+            aria-label={tx("Show remote-only files")}
+            aria-pressed={showRemote}
+            onClick={() => setShowRemote(!showRemote)}
+          >
+            ←
+          </button>
+          <span className={styles.separator} />
+          <label className={styles.compareBy}>
+            <T>Compare by:</T>
+            <select
+              aria-label={tx("Compare by")}
+              value={compareBy}
+              disabled={sync.running}
+              onChange={(e) => changeCompareBy(e.target.value as CompareBy)}
+            >
+              <option value="metadata">{tx("Size and Timestamp")}</option>
+              <option value="content">{tx("Binary Content")}</option>
+            </select>
+          </label>
+          <span className={styles.separator} />
+          <IconButton
+            icon="run"
+            title="Synchronize Selected"
+            shortcut="Enter"
+            size="small"
+            disabled={busy || !selectedSteps.length}
+            onClick={() => void synchronize("selected")}
+          />
+          {progress !== null && (
+            <>
+              <Spinner size={14} />
+              <span className={styles.note} role="status">
+                {txt(`Comparing contents: ${progress} of ${entries?.length ?? 0}`)}
+              </span>
+              <IconButton
+                icon="stop"
+                title="Stop content comparison"
+                size="small"
+                onClick={() => changeCompareBy("metadata")}
+              />
+            </>
+          )}
+          <label className={styles.fileFilter}>
+            <T>Filter:</T>
+            <Input aria-label={tx("Filter by name")} value={filter} onChange={(e) => setFilter(e.target.value)} />
+          </label>
+        </div>
+        <div className={styles.comparisonRoots}>
+          <span title={root ?? ""}>
+            <Icon name="folder" size={14} />
+            <span>{root ?? tx("Local files")}</span>
+          </span>
+          <span title={server?.rootPath}>
+            <Icon name="web" size={14} />
+            <span>
+              {sync.serverName}: {server?.rootPath || "/"}
+            </span>
+          </span>
+        </div>
+        {sync.error && (
+          <div className={styles.error} role="alert">
+            {sync.error}
+          </div>
+        )}
+        {!!sync.skipped?.length && (
+          <div className={styles.note}>
+            {txt(`Skipped: ${sync.skipped.length}`)}: {sync.skipped.map((item) => item.path).join(", ")}
+          </div>
+        )}
+        {!entries && !sync.error && (
+          <div className={styles.center} role="status">
+            <Spinner />
+            <T>Comparing local and remote files…</T>
+          </div>
+        )}
+        {sync.running && (
+          <div className={styles.center} role="status">
+            <Spinner size={14} />
+            <T>Synchronizing…</T>
+          </div>
+        )}
+        {entries && (
+          <SplitGroup orientation="vertical" className={styles.comparisonSplit}>
+            <SplitPanel defaultSize="32%" minSize="100px">
+              <div className={styles.fileList}>
+                <div className={styles.syncTableHost}>
+                  <table
+                    className={styles.syncTable}
+                    role="grid"
+                    tabIndex={0}
+                    aria-label={tx("Files to synchronize")}
+                    aria-activedescendant={selected ? `deploy-row-${shown.indexOf(selected)}` : undefined}
+                    onKeyDown={onTableKey}
+                  >
+                    <colgroup>
+                      <col />
+                      <col className={styles.sizeCol} />
+                      <col className={styles.timeCol} />
+                      <col className={styles.operationCol} />
+                      <col className={styles.timeCol} />
+                      <col className={styles.sizeCol} />
+                      <col />
+                    </colgroup>
+                    <thead>
+                      <tr>
+                        <th>{tx("Local name")}</th>
+                        <th>{tx("Size")}</th>
+                        <th>{tx("Date")}</th>
+                        <th aria-label={tx("Action")}>↔</th>
+                        <th>{tx("Date")}</th>
+                        <th>{tx("Size")}</th>
+                        <th>{tx("Remote name")}</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {!shown.length && (
+                        <tr>
+                          <td colSpan={7} className={styles.emptyCell}>
+                            <T>No matching differences</T>
+                          </td>
+                        </tr>
+                      )}
+                      {shown.map((entry, index) => (
+                        <tr
+                          key={entry.path}
+                          id={`deploy-row-${index}`}
+                          aria-selected={selected?.path === entry.path}
+                          className={clsx(
+                            styles[`status-${entry.status}`],
+                            sync.choices[entry.path] === "skip" && styles.skipped,
+                          )}
+                          onClick={(event) => {
+                            setSelectedPath(entry.path);
+                            if (!(event.target as HTMLElement).closest("select, button, input"))
+                              event.currentTarget.closest("table")?.focus({ preventScroll: true });
+                          }}
+                        >
+                          <td title={entry.local && root ? `${root}/${entry.path}` : tx("(does not exist)")}>
+                            {entry.local && (
+                              <span className={styles.fileName}>
+                                <Icon name={fileIconName(entry.path)} size={14} />
+                                {entry.path}
+                              </span>
+                            )}
+                          </td>
+                          <td className={styles.num}>{entry.local ? formatSize(entry.local.size) : ""}</td>
+                          <td>{formatTime(entry.local?.mtime)}</td>
+                          <td className={styles.operationCell}>
+                            <select
+                              className={styles.choice}
+                              aria-label={`${tx("Action")} ${entry.path}`}
+                              title={checkErrors[entry.path] ?? tx(STATUS[entry.status])}
+                              value={sync.choices[entry.path] ?? "skip"}
+                              disabled={busy}
+                              onChange={(e) => choose(entry, e.target.value as SyncChoice)}
+                            >
+                              {syncChoices(entry).map((choice) => (
+                                <option key={choice} value={choice} title={tx(CHOICES[choice][1])}>
+                                  {CHOICES[choice][0]} {tx(CHOICES[choice][1])}
+                                </option>
+                              ))}
+                            </select>
+                          </td>
+                          <td>{formatTime(entry.remote?.mtime)}</td>
+                          <td className={styles.num}>{entry.remote ? formatSize(entry.remote.size) : ""}</td>
+                          <td title={entry.remotePath}>
+                            {entry.remote && (
+                              <span className={styles.fileName}>
+                                <Icon name={fileIconName(entry.path)} size={14} />
+                                {entry.path}
+                              </span>
+                            )}
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+                <div className={styles.listHint}>
+                  <T>
+                    Space changes the selected operation. Enter synchronizes the selected file. Synchronize All applies
+                    all chosen operations.
+                  </T>
+                </div>
+              </div>
+            </SplitPanel>
+            <SplitHandle aria-label={tx("Resize file list and diff preview")} />
+            <SplitPanel defaultSize="68%" minSize="160px">
+              {selected && checkErrors[selected.path] && (
+                <div className={styles.error} role="alert">
+                  {checkErrors[selected.path]}
+                </div>
+              )}
+              {comparison ? (
+                <SyncPreview key={selected?.path ?? "empty"} entry={previewEntry} comparison={comparison} />
+              ) : (
+                <div className={styles.center}>
+                  <T>The deployment server or project is no longer available</T>
+                </div>
+              )}
+            </SplitPanel>
+          </SplitGroup>
+        )}
+      </div>
+    </ComparisonFrame>
+  );
+}
+
+export function SyncDialog({
+  standalone = false,
+  beforeSynchronize,
+}: {
+  standalone?: boolean;
+  beforeSynchronize?: (steps: SyncStep[]) => Promise<void>;
+}) {
+  const sync = useDeployment((s) => s.sync);
+  return sync ? <SyncComparison sync={sync} standalone={standalone} beforeSynchronize={beforeSynchronize} /> : null;
+}
diff --git a/src/features/deployment/SyncPreview.test.tsx b/src/features/deployment/SyncPreview.test.tsx
new file mode 100644
index 000000000..6765e852c
--- /dev/null
+++ b/src/features/deployment/SyncPreview.test.tsx
@@ -0,0 +1,72 @@
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { SyncEntry } from "@/platform/ipc";
+import { registerEditorKind } from "@/workbench/contributions";
+import type { DeploymentComparison, DeploymentPreview } from "./comparison";
+import { SyncPreview } from "./SyncPreview";
+
+// The diff viewer comes from the vcs feature through its editor kind.
+registerEditorKind({
+  kind: "diff",
+  title: () => "diff",
+  component: ({ input }) => (
+    <div data-testid="diff" data-mode={(input.data as { mode?: string }).mode}>
+      {JSON.stringify(input.data)}
+    </div>
+  ),
+});
+
+const entry = (path: string) => ({ path, remotePath: `/srv/${path}` }) as SyncEntry;
+const result = (text: string): DeploymentPreview => ({
+  kind: "text",
+  data: {
+    path: "/work/file.php",
+    title: "file.php",
+    left: { type: "text", text: "local", label: "Local" },
+    right: { type: "text", text, label: "Remote" },
+  },
+});
+
+describe("deployment diff preview", () => {
+  it("ignores a late response for a file that is no longer selected", async () => {
+    let finish!: (value: DeploymentPreview) => void;
+    const preview = vi
+      .fn()
+      .mockReturnValueOnce(
+        new Promise<DeploymentPreview>((resolve) => {
+          finish = resolve;
+        }),
+      )
+      .mockResolvedValue(result("current"));
+    const comparison: DeploymentComparison = { preview, equal: vi.fn() };
+    const mounted = render(<SyncPreview entry={entry("first.php")} comparison={comparison} />);
+    const firstSignal = preview.mock.calls[0]![1] as AbortSignal;
+    mounted.rerender(<SyncPreview entry={entry("second.php")} comparison={comparison} />);
+    expect(firstSignal.aborted).toBe(true);
+    expect(await screen.findByTestId("diff")).toHaveTextContent("current");
+    await act(async () => finish(result("stale")));
+    expect(screen.getByTestId("diff")).not.toHaveTextContent("stale");
+    expect(screen.getByTestId("diff")).toHaveAttribute("data-mode", "split");
+  });
+  it("shows read errors and allows retrying without closing the comparison", async () => {
+    const preview = vi.fn().mockRejectedValueOnce(new Error("Offline")).mockResolvedValue(result("recovered"));
+    render(<SyncPreview entry={entry("file.php")} comparison={{ preview, equal: vi.fn() }} />);
+    expect(await screen.findByRole("alert")).toHaveTextContent("Offline");
+    fireEvent.click(screen.getByRole("button", { name: "Retry" }));
+    expect(await screen.findByTestId("diff")).toHaveTextContent("recovered");
+  });
+  it.each(["binary", "tooLarge"] as const)("explains why %s files have no text preview", async (kind) => {
+    render(
+      <SyncPreview
+        entry={entry("file.bin")}
+        comparison={{ preview: vi.fn().mockResolvedValue({ kind }), equal: vi.fn() }}
+      />,
+    );
+    expect(
+      await screen.findByText(
+        kind === "binary" ? "Binary files cannot be shown as text" : /too large for the text preview/,
+      ),
+    ).toBeInTheDocument();
+    expect(screen.queryByTestId("diff")).not.toBeInTheDocument();
+  });
+});
diff --git a/src/features/deployment/SyncPreview.tsx b/src/features/deployment/SyncPreview.tsx
new file mode 100644
index 000000000..8e0099287
--- /dev/null
+++ b/src/features/deployment/SyncPreview.tsx
@@ -0,0 +1,93 @@
+import { Suspense, useEffect, useState } from "react";
+import type { SyncEntry } from "@/platform/ipc";
+import { txTemplate } from "@/platform/i18n";
+import { Button, Spinner, T } from "@/ui";
+import { useContributions } from "@/workbench/contributions";
+import type { DeploymentComparison, DeploymentDiff, DeploymentPreview } from "./comparison";
+import styles from "./Deployment.module.css";
+
+/** An input of the diff viewer (editor kind `diff`), embedded and side by side. */
+function diffInput(data: DeploymentDiff) {
+  return {
+    kind: "diff",
+    key: `deployment:${data.path}`,
+    path: data.path,
+    data: { ...data, embedded: true, mode: "split" },
+  };
+}
+
+export function SyncPreview({ entry, comparison }: { entry: SyncEntry | null; comparison: DeploymentComparison }) {
+  const [loaded, setLoaded] = useState<{
+    comparison: DeploymentComparison;
+    entry: SyncEntry;
+    attempt: number;
+    result: DeploymentPreview | null;
+    error: string | null;
+  } | null>(null);
+  const [attempt, setAttempt] = useState(0);
+  const current =
+    loaded?.comparison === comparison && loaded.entry === entry && loaded.attempt === attempt ? loaded : null;
+  const result = current?.result;
+  const error = current?.error;
+  const diffViewer = useContributions((s) => s.editorKinds.get("diff"));
+  useEffect(() => {
+    const abort = new AbortController();
+    if (entry)
+      void comparison.preview(entry, abort.signal).then(
+        (value) => {
+          if (!abort.signal.aborted) setLoaded({ comparison, entry, attempt, result: value, error: null });
+        },
+        (e: unknown) => {
+          if (!abort.signal.aborted)
+            setLoaded({
+              comparison,
+              entry,
+              attempt,
+              result: null,
+              error: txTemplate(e instanceof Error ? e.message : String(e)),
+            });
+        },
+      );
+    return () => abort.abort();
+  }, [entry, comparison, attempt]);
+
+  return (
+    <div className={styles.preview} aria-label="Deployment content comparison">
+      {!entry ? (
+        <div className={styles.center}>
+          <T>Select a file to compare its contents</T>
+        </div>
+      ) : error ? (
+        <div className={styles.previewMessage} role="alert">
+          <div className={styles.error}>{error}</div>
+          <Button size="small" onClick={() => setAttempt((n) => n + 1)}>
+            Retry
+          </Button>
+        </div>
+      ) : !result ? (
+        <div className={styles.center} role="status">
+          <Spinner size={14} />
+          <T>Loading file contents…</T>
+        </div>
+      ) : result.kind === "binary" ? (
+        <div className={styles.center}>
+          <T>Binary files cannot be shown as text</T>
+        </div>
+      ) : result.kind === "tooLarge" ? (
+        <div className={styles.center}>
+          <T>This file is too large for the text preview. Use Binary Content to compare it.</T>
+        </div>
+      ) : (
+        <Suspense
+          fallback={
+            <div className={styles.center}>
+              <Spinner size={14} />
+            </div>
+          }
+        >
+          {diffViewer && <diffViewer.component input={diffInput(result.data)} />}
+        </Suspense>
+      )}
+    </div>
+  );
+}
diff --git a/src/features/deployment/actions.test.tsx b/src/features/deployment/actions.test.tsx
index f3a1ae487..63ab8cdb8 100644
--- a/src/features/deployment/actions.test.tsx
+++ b/src/features/deployment/actions.test.tsx
@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { DeploymentServerValid } from "@/platform/remoteSettings";
+import type { SyncEntry } from "@/platform/ipc";
 
 const mocks = vi.hoisted(() => ({
   actions: [] as { id: string; run: (context: { arg: string[] }) => unknown }[],
@@ -9,6 +10,17 @@ const mocks = vi.hoisted(() => ({
   notify: vi.fn(),
   upload: vi.fn(),
   compare: vi.fn(),
+  sync: vi.fn(),
+  save: vi.fn(),
+  release: vi.fn(),
+  attachedPaths: [] as string[],
+  desktop: false,
+  openWindow: vi.fn(),
+}));
+vi.mock("./windowBridge", () => ({ showDeploymentComparison: mocks.openWindow }));
+vi.mock("@/editor/api", () => ({
+  editorsFor: (path: string) => (mocks.attachedPaths.includes(path) ? [{}] : []),
+  attachDocument: async () => ({ save: mocks.save, release: mocks.release }),
 }));
 vi.mock("@/platform/actions", () => ({
   executeAction: vi.fn(),
@@ -38,13 +50,15 @@ vi.mock("@/platform/ipc", () => ({
   call: (value: unknown) => value,
   nextRequestId: () => 1,
   isCancelled: () => false,
+  isTauri: () => mocks.desktop,
   commands: {
     deployCoverage: async () => mocks.coverage,
     deployUpload: mocks.upload,
     deployCompare: mocks.compare,
+    deploySync: mocks.sync,
   },
 }));
-import { registerDeploymentActions } from "./actions";
+import { registerDeploymentActions, runSync } from "./actions";
 import { useDeployment } from "./store";
 
 async function run(id: string, paths = ["/project/a", "/project/b"]) {
@@ -69,10 +83,53 @@ beforeEach(() => {
   mocks.choose.mockResolvedValue(null);
   mocks.upload.mockResolvedValue({ files: 1, skipped: 1, errors: [] });
   mocks.compare.mockResolvedValue([]);
+  mocks.sync.mockResolvedValue({ files: 1, skipped: 0, errors: [] });
+  mocks.save.mockResolvedValue(undefined);
+  mocks.attachedPaths = [];
+  mocks.desktop = false;
+  mocks.openWindow.mockResolvedValue(undefined);
   useDeployment.setState({ sync: null });
   registerDeploymentActions();
 });
 describe("deployment eligibility", () => {
+  it("keeps upstream's server-specific explanation when only one server is configured", async () => {
+    mocks.servers = [mocks.servers[0]!];
+    mocks.coverage[0]!.paths = [];
+    await run("deployment.uploadTo");
+    expect(mocks.notify).toHaveBeenCalledWith(
+      expect.objectContaining({ title: "No selected paths can be deployed to one" }),
+    );
+    expect(mocks.notify.mock.calls[0]![0].body.props.report.errors).toEqual(mocks.coverage[0]!.skipped);
+  });
+  it("opens the selected server and paths in a native window on desktop without an in-page comparison", async () => {
+    mocks.desktop = true;
+    mocks.choose.mockResolvedValue("one");
+    await run("deployment.syncWith");
+    await vi.waitFor(() => expect(mocks.openWindow).toHaveBeenCalledWith("one", ["/project/a", "/project/b"]));
+    expect(useDeployment.getState().sync).toBeNull();
+    expect(mocks.compare).not.toHaveBeenCalled();
+  });
+  it("saves edits made in the local diff before synchronization and stops if saving fails", async () => {
+    await run("deployment.syncWith");
+    mocks.choose.mockResolvedValue("one");
+    await run("deployment.syncWith");
+    await vi.waitFor(() => expect(useDeployment.getState().sync?.entries).toEqual([]));
+    const sync = useDeployment.getState().sync!;
+    mocks.attachedPaths = ["/project/a"];
+    await runSync([
+      { path: "a", action: "upload" },
+      { path: "b", action: "download" },
+    ]);
+    expect(mocks.save).toHaveBeenCalledOnce();
+    expect(mocks.release).toHaveBeenCalledOnce();
+    expect(mocks.save.mock.invocationCallOrder[0]).toBeLessThan(mocks.sync.mock.invocationCallOrder[0]!);
+    useDeployment.setState({ sync });
+    mocks.sync.mockClear();
+    mocks.save.mockRejectedValueOnce(new Error("Cannot save local file"));
+    await runSync([{ path: "a", action: "upload" }]);
+    expect(mocks.sync).not.toHaveBeenCalled();
+    expect(useDeployment.getState().sync?.error).toBe("Cannot save local file");
+  });
   it.each(["deployment.uploadTo", "deployment.downloadFrom", "deployment.syncWith"])(
     "filters %s and keeps a single option visible",
     async (id) => {
@@ -80,17 +137,24 @@ describe("deployment eligibility", () => {
       expect(mocks.choose).toHaveBeenCalledWith(expect.objectContaining({ items: ["one"] }));
     },
   );
-  it("explains an empty match and links settings", async () => {
-    mocks.coverage[0]!.paths = [];
-    await run("deployment.uploadTo");
-    expect(mocks.choose).not.toHaveBeenCalled();
-    expect(mocks.notify).toHaveBeenCalledWith(
-      expect.objectContaining({
-        title: "No deployment server covers the selected paths",
-        actions: [expect.objectContaining({ label: "Configure…" })],
-      }),
-    );
-  });
+  it.each(["deployment.uploadTo", "deployment.downloadFrom", "deployment.syncWith"])(
+    "explains the rejected paths for %s and links settings",
+    async (id) => {
+      mocks.coverage[0]!.paths = [];
+      await run(id);
+      expect(mocks.choose).not.toHaveBeenCalled();
+      expect(mocks.notify).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: "No deployment server covers the selected paths",
+          actions: [expect.objectContaining({ label: "Configure…" })],
+        }),
+      );
+      expect(mocks.notify.mock.calls[0]![0].body.props.report.errors).toEqual([
+        { path: "/project/b", message: "one: Not covered by this server's mappings" },
+      ]);
+      expect(mocks.compare).not.toHaveBeenCalled();
+    },
+  );
   it("explains why the default cannot deploy the named file", async () => {
     mocks.coverage[0]!.paths = [];
     await run("deployment.uploadToDefault");
@@ -104,4 +168,64 @@ describe("deployment eligibility", () => {
     await vi.waitFor(() => expect(mocks.compare).toHaveBeenCalledTimes(2));
     expect(useDeployment.getState().sync?.skipped?.[0]?.path).toBe("/project/b");
   });
+  it("keeps the comparison and other choices after synchronizing a single file, then supports the next file", async () => {
+    mocks.choose.mockResolvedValue("one");
+    await run("deployment.syncWith");
+    await vi.waitFor(() => expect(useDeployment.getState().sync?.entries).toEqual([]));
+    const entries: SyncEntry[] = ["a", "b"].map((path) => ({
+      path,
+      remotePath: `/remote/${path}`,
+      local: { size: 10, mtime: 2 },
+      remote: { size: 5, mtime: 1 },
+      status: "localNewer",
+    }));
+    useDeployment.setState((state) => ({
+      sync: { ...state.sync!, entries, choices: { a: "upload", b: "deleteRemote" } },
+    }));
+    const refreshed = { ...entries[0]!, remote: entries[0]!.local, status: "same" as const };
+    mocks.compare.mockResolvedValueOnce([refreshed]);
+    await runSync([{ path: "a", action: "upload" }], "selected");
+    expect(mocks.sync).toHaveBeenLastCalledWith([{ path: "a", action: "upload" }], "one", 1);
+    expect(mocks.compare).toHaveBeenLastCalledWith("/project/a", "one", 1);
+    expect(useDeployment.getState().sync).toMatchObject({
+      running: false,
+      request: null,
+      choices: { a: "skip", b: "deleteRemote" },
+      entries: [refreshed, entries[1]],
+    });
+    mocks.compare.mockResolvedValueOnce([{ ...entries[1]!, remote: null, status: "localOnly" }]);
+    await runSync([{ path: "b", action: "deleteRemote" }], "selected");
+    expect(useDeployment.getState().sync?.choices).toEqual({ a: "skip", b: "skip" });
+    expect(useDeployment.getState().sync?.entries).toHaveLength(2);
+  });
+  it("retains failed selected operations for retry and does not change pending files when refresh fails", async () => {
+    mocks.choose.mockResolvedValue("one");
+    await run("deployment.syncWith");
+    await vi.waitFor(() => expect(useDeployment.getState().sync?.entries).toEqual([]));
+    const entries: SyncEntry[] = ["a", "b"].map((path) => ({
+      path,
+      remotePath: `/remote/${path}`,
+      local: { size: 10, mtime: 2 },
+      remote: null,
+      status: "localOnly",
+    }));
+    useDeployment.setState((state) => ({ sync: { ...state.sync!, entries, choices: { a: "upload", b: "upload" } } }));
+    mocks.sync.mockResolvedValueOnce({ files: 0, skipped: 0, errors: [{ path: "a", message: "Permission denied" }] });
+    mocks.compare.mockResolvedValueOnce([entries[0]]);
+    await runSync([{ path: "a", action: "upload" }], "selected");
+    expect(useDeployment.getState().sync).toMatchObject({
+      running: false,
+      choices: { a: "upload", b: "upload" },
+      error: "a: Permission denied",
+    });
+    mocks.compare.mockRejectedValueOnce(new Error("Connection lost"));
+    await runSync([{ path: "a", action: "upload" }], "selected");
+    expect(useDeployment.getState().sync).toMatchObject({
+      running: false,
+      request: null,
+      choices: { a: "skip", b: "upload" },
+      entries,
+    });
+    expect(useDeployment.getState().sync?.error).toContain("Could not refresh comparison: a: Connection lost");
+  });
 });
diff --git a/src/features/deployment/actions.tsx b/src/features/deployment/actions.tsx
index 9a9dbcfe1..2c558afbb 100644
--- a/src/features/deployment/actions.tsx
+++ b/src/features/deployment/actions.tsx
@@ -1,8 +1,18 @@
 /** Deployment actions: upload / download / delete / sync / open the deployed URL. */
 import { executeAction, registerActions } from "@/platform/actions";
+import { attachDocument, editorsFor } from "@/editor/api";
 import { getContext } from "@/platform/context";
-import { call, commands, isCancelled, nextRequestId, type SyncAction, type TransferReport } from "@/platform/ipc";
-import { txTemplate, useTxTemplate } from "@/platform/i18n";
+import {
+  call,
+  commands,
+  isCancelled,
+  isTauri,
+  nextRequestId,
+  type TransferReport,
+  type SyncEntry,
+  type SyncStep,
+} from "@/platform/ipc";
+import { tx, txTemplate, useTxTemplate } from "@/platform/i18n";
 import { openExternalUrl } from "@/platform/openUrl";
 import { relativePath, useProject } from "@/platform/project";
 import type { AutoUploadValid, DeploymentServerValid } from "@/platform/remoteSettings";
@@ -14,6 +24,7 @@ import { initialSyncChoices, resolveServer, serverLabel, summarizeReport, target
 import { withSsh } from "./ssh";
 import { REMOTE_HOST_WINDOW, patchSync, useDeployment } from "./store";
 import styles from "./Deployment.module.css";
+import { showDeploymentComparison } from "./windowBridge";
 
 const GROUP = "tools";
 const CATEGORY = "Deployment";
@@ -90,8 +101,17 @@ async function pickServer(title: string, paths: string[]): Promise<DeploymentSer
   const servers = configured.filter((server) => coverage.some((c) => c.server === server.id && c.paths.length));
   if (!servers.length) {
     // One server: say why, as an explicit upload to it would.
-    if (configured.length === 1) notifyNoCoverage(configured[0], coverage[0]?.skipped);
-    else notifyNoCoverage();
+    if (configured.length === 1)
+      notifyNoCoverage(configured[0], coverage.find((c) => c.server === configured[0]!.id)?.skipped);
+    else {
+      const skipped = configured.flatMap((server) =>
+        (coverage.find((c) => c.server === server.id)?.skipped ?? []).map((error) => ({
+          ...error,
+          message: `${serverLabel(server)}: ${error.message}`,
+        })),
+      );
+      notifyNoCoverage(undefined, skipped);
+    }
     return null;
   }
   const labels = servers.map(serverLabel);
@@ -250,20 +270,86 @@ export function closeSync() {
   useDeployment.setState({ sync: null });
 }
 
-export async function runSync(steps: { path: string; action: SyncAction }[]) {
+export type SyncRunMode = "all" | "selected";
+
+export async function runSync(steps: SyncStep[], mode: SyncRunMode = "all") {
   const sync = useDeployment.getState().sync;
   const server = sync && deployment().servers.find((s) => s.id === sync.server);
-  if (!sync || !server) return;
+  if (!sync || !server || !steps.length) return;
   const request = nextRequestId();
-  patchSync({ running: true, request });
+  patchSync({ running: true, request, error: null });
   try {
+    // The embedded diff can edit the local side. Flush those live documents
+    // before uploading, so the server receives the content the user reviewed.
+    const root = projectRoot();
+    for (const step of steps) {
+      if (step.action !== "upload" || !root) continue;
+      const path = `${root.replace(/\/$/, "")}/${step.path}`;
+      if (!editorsFor(path).length) continue;
+      const document = await attachDocument(path);
+      try {
+        await document.save();
+      } finally {
+        document.release();
+      }
+    }
+    if (useDeployment.getState().sync?.request !== request) return;
     const report = await withSsh(server.kind === "sftp" ? server.sshConfig : "", () =>
       call(commands.deploySync(steps, server.id, request)),
     );
-    useDeployment.setState({ sync: null });
-    report.skipped += sync.skipped.length;
+    if (useDeployment.getState().sync?.request !== request) return;
+    if (mode === "selected" && root) {
+      const refreshed = new Map<string, SyncEntry>();
+      const checked = new Set<string>();
+      const refreshErrors: string[] = [];
+      for (const step of steps) {
+        if (useDeployment.getState().sync?.request !== request) return;
+        try {
+          const entries = await withSsh(server.kind === "sftp" ? server.sshConfig : "", () =>
+            call(commands.deployCompare(`${root.replace(/\/$/, "")}/${step.path}`, server.id, request)),
+          );
+          checked.add(step.path);
+          const entry = entries.find((entry) => entry.path === step.path);
+          if (entry) refreshed.set(step.path, entry);
+        } catch (error) {
+          if (isCancelled(error)) throw error;
+          refreshErrors.push(`${step.path}: ${errorText(error)}`);
+        }
+      }
+      const current = useDeployment.getState().sync;
+      if (current?.request !== request) return;
+      const failed = new Set(report.errors.map((error) => error.path));
+      // A skipped or interrupted batch does not identify every completed file.
+      const completed = report.skipped === 0 && report.files === steps.length - failed.size;
+      const choices = { ...current.choices };
+      if (completed) for (const step of steps) if (!failed.has(step.path)) choices[step.path] = "skip";
+      const entries =
+        current.entries?.flatMap((entry) => {
+          if (!checked.has(entry.path)) return [entry];
+          const updated = refreshed.get(entry.path);
+          if (updated) return [updated];
+          delete choices[entry.path];
+          return [];
+        }) ?? null;
+      patchSync({
+        entries,
+        choices,
+        running: false,
+        request: null,
+        error:
+          [
+            ...report.errors.map((error) => `${error.path}: ${error.message}`),
+            ...refreshErrors.map((error) => tx`Could not refresh comparison: ${error}`),
+          ].join("\n") || null,
+      });
+    } else {
+      useDeployment.setState({ sync: null });
+      report.skipped += sync.skipped.length;
+    }
     showReport(report, "sync", server);
+    return report;
   } catch (e) {
+    if (useDeployment.getState().sync?.request !== request) return;
     if (isCancelled(e)) patchSync({ running: false, request: null });
     else patchSync({ running: false, request: null, error: errorText(e) });
   }
@@ -367,7 +453,15 @@ export function registerDeploymentActions(): () => void {
         const target = paths[0] ?? projectRoot();
         if (!target) return;
         const targets = paths.length ? paths : [target];
-        void pickServer("Sync with Deployed to", targets).then((server) => server && openSync(server, targets));
+        void pickServer("Sync with Deployed to", targets).then(async (server) => {
+          if (!server) return;
+          if (!isTauri()) return openSync(server, targets);
+          try {
+            await showDeploymentComparison(server.id, targets);
+          } catch (error) {
+            showFailure("Cannot open comparison for {server}", server, error);
+          }
+        });
       },
     },
     {
diff --git a/src/features/deployment/comparison.test.ts b/src/features/deployment/comparison.test.ts
new file mode 100644
index 000000000..6df84c506
--- /dev/null
+++ b/src/features/deployment/comparison.test.ts
@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { SyncEntry } from "@/platform/ipc";
+import { DEFAULT_DEPLOYMENT_SERVER } from "@/platform/remoteSettings";
+
+const mocks = vi.hoisted(() => ({ remote: vi.fn(), probe: vi.fn(), text: vi.fn(), range: vi.fn() }));
+vi.mock("@/platform/ipc", () => ({
+  call: (value: unknown) => value,
+  commands: { remoteOpen: mocks.remote, fsProbe: mocks.probe, fsReadText: mocks.text, fsReadRange: mocks.range },
+}));
+vi.mock("./ssh", () => ({ withSsh: (_: unknown, run: () => unknown) => run() }));
+import { createDeploymentComparison } from "./comparison";
+
+const server = { ...DEFAULT_DEPLOYMENT_SERVER, id: "s1", name: "Staging", sshConfig: "ssh" };
+const entry = (patch: Partial<SyncEntry> = {}): SyncEntry => ({
+  path: "src/a.php",
+  remotePath: "/srv/app/src/a.php",
+  status: "same",
+  local: { size: 4, mtime: 1 },
+  remote: { size: 4, mtime: 1 },
+  ...patch,
+});
+const signal = () => new AbortController().signal;
+beforeEach(() => {
+  vi.resetAllMocks();
+  mocks.remote.mockResolvedValue("/cache/a.php");
+  mocks.probe.mockResolvedValue({ size: 4, binary: false, tooLarge: false });
+  mocks.text.mockResolvedValue("old\n");
+  mocks.range.mockResolvedValue({ total: 4, data: "b2xkCg==" });
+});
+
+describe("deployment content snapshots", () => {
+  it("keeps the local document live and the remote side immutable, sharing one downloaded snapshot", async () => {
+    const compare = createDeploymentComparison(server, "/work/app/");
+    expect(await compare.preview(entry(), signal())).toMatchObject({
+      kind: "text",
+      data: {
+        path: "/work/app/src/a.php",
+        left: { type: "file", path: "/work/app/src/a.php" },
+        right: { type: "text", text: "old\n", label: "Staging: /srv/app/src/a.php" },
+      },
+    });
+    expect(mocks.remote).toHaveBeenCalledWith({ kind: "sftp", ssh: "ssh" }, "/srv/app/src/a.php");
+    expect(mocks.text).toHaveBeenCalledWith("/cache/a.php");
+    await compare.equal(entry(), signal());
+    expect(mocks.remote).toHaveBeenCalledTimes(1);
+  });
+  it("represents missing sides without reading missing files", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    expect(await compare.preview(entry({ remote: null }), signal())).toMatchObject({
+      data: { right: { type: "text", text: "", label: expect.stringContaining("does not exist") } },
+    });
+    expect(mocks.remote).not.toHaveBeenCalled();
+    expect(mocks.text).not.toHaveBeenCalled();
+    mocks.probe.mockClear();
+    expect(await compare.preview(entry({ local: null }), signal())).toMatchObject({
+      data: { left: { type: "text", text: "" }, right: { text: "old\n" } },
+    });
+    expect(mocks.probe).toHaveBeenCalledExactlyOnceWith("/cache/a.php");
+  });
+  it("does not decode binaries or download oversized text previews", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    expect(await compare.preview(entry({ local: { size: 20_000_000, mtime: 1 } }), signal())).toEqual({
+      kind: "tooLarge",
+    });
+    expect(mocks.remote).not.toHaveBeenCalled();
+    mocks.probe.mockResolvedValue({ size: 4, binary: true });
+    expect(await compare.preview(entry(), signal())).toEqual({ kind: "binary" });
+    expect(mocks.text).not.toHaveBeenCalled();
+  });
+  it("compares bytes even when size and timestamps match", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    mocks.range.mockImplementation(async (path: string) => ({
+      total: 4,
+      data: path.startsWith("/work") ? "bmV3Cg==" : "b2xkCg==",
+    }));
+    expect(await compare.equal(entry(), signal())).toBe(false);
+    mocks.range.mockResolvedValue({ total: 4, data: "b2xkCg==" });
+    expect(await compare.equal(entry({ remote: { size: 4, mtime: 99 } }), signal())).toBe(true);
+  });
+  it("uses bounded reads and stops at the first differing block", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    const large = entry({ local: { size: 150_000, mtime: 1 }, remote: { size: 150_000, mtime: 1 } });
+    mocks.range.mockImplementation(async (path: string, offset: number) => ({
+      total: 150_000,
+      data: offset >= 65_536 ? path : "same",
+    }));
+    expect(await compare.equal(large, signal())).toBe(false);
+    expect(mocks.range).toHaveBeenCalledTimes(4);
+    expect(mocks.range.mock.calls.every(([, , len]) => len === 65_536)).toBe(true);
+  });
+  it("detects changed sizes during comparison and handles empty files", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    mocks.range.mockResolvedValue({ total: 5, data: "changed" });
+    await expect(compare.equal(entry(), signal())).rejects.toThrow("changed during comparison");
+    mocks.range.mockResolvedValue({ total: 0, data: "" });
+    expect(await compare.equal(entry({ local: { size: 0, mtime: 1 }, remote: { size: 0, mtime: 1 } }), signal())).toBe(
+      true,
+    );
+    mocks.remote.mockClear();
+    expect(await compare.equal(entry({ remote: { size: 8, mtime: 1 } }), signal())).toBe(false);
+    expect(mocks.remote).not.toHaveBeenCalled();
+  });
+  it("does not continue after selection is cancelled and retries failed downloads", async () => {
+    const compare = createDeploymentComparison(server, "/work/app");
+    const abort = new AbortController();
+    mocks.remote.mockImplementationOnce(async () => {
+      abort.abort();
+      return "/cache/a.php";
+    });
+    await expect(compare.preview(entry(), abort.signal)).rejects.toMatchObject({ name: "AbortError" });
+    expect(mocks.text).not.toHaveBeenCalled();
+    const retry = createDeploymentComparison(server, "/work/app");
+    mocks.remote.mockRejectedValueOnce(new Error("Offline"));
+    await expect(retry.preview(entry(), signal())).rejects.toThrow("Offline");
+    await expect(retry.preview(entry(), signal())).resolves.toMatchObject({ kind: "text" });
+  });
+});
diff --git a/src/features/deployment/comparison.ts b/src/features/deployment/comparison.ts
new file mode 100644
index 000000000..67b71ce0d
--- /dev/null
+++ b/src/features/deployment/comparison.ts
@@ -0,0 +1,91 @@
+/** Read-only remote snapshots for the deployment comparison; project files are never downloaded over. */
+import { call, commands, type SyncEntry } from "@/platform/ipc";
+import { tx } from "@/platform/i18n";
+import { deploymentConnection, type DeploymentServerValid } from "@/platform/remoteSettings";
+import { withSsh } from "./ssh";
+
+const PREVIEW_LIMIT = 8 * 1024 * 1024;
+const BLOCK_SIZE = 64 * 1024;
+
+/** The data of a `diff` editor input (the diff viewer's): the local file, editable, next to the server's text. */
+export interface DeploymentDiff {
+  path: string;
+  title: string;
+  left: { type: "file"; path: string; label: string } | { type: "text"; text: string; label: string };
+  right: { type: "text"; text: string; label: string };
+}
+
+export type DeploymentPreview = { kind: "text"; data: DeploymentDiff } | { kind: "binary" } | { kind: "tooLarge" };
+
+export function createDeploymentComparison(server: DeploymentServerValid, root: string) {
+  // Only the downloaded path is cached, never a live remote document. The diff
+  // receives immutable text, so its merge controls cannot save to the server.
+  const snapshots = new Map<string, Promise<string>>();
+  const localPath = (entry: SyncEntry) => `${root.replace(/\/$/, "")}/${entry.path}`;
+  const remoteSnapshot = (entry: SyncEntry) => {
+    let pending = snapshots.get(entry.remotePath);
+    if (!pending) {
+      pending = withSsh(server.kind === "sftp" ? server.sshConfig : "", () =>
+        call(commands.remoteOpen(deploymentConnection(server), entry.remotePath)),
+      );
+      snapshots.set(entry.remotePath, pending);
+      void pending.catch(() => snapshots.delete(entry.remotePath));
+    }
+    return pending;
+  };
+
+  return {
+    async preview(entry: SyncEntry, signal: AbortSignal): Promise<DeploymentPreview> {
+      signal.throwIfAborted();
+      if (Math.max(entry.local?.size ?? 0, entry.remote?.size ?? 0) > PREVIEW_LIMIT) return { kind: "tooLarge" };
+      const remote = entry.remote ? await remoteSnapshot(entry) : null;
+      signal.throwIfAborted();
+      const probes = await Promise.all(
+        [entry.local ? localPath(entry) : null, remote].map((path) => (path ? call(commands.fsProbe(path)) : null)),
+      );
+      signal.throwIfAborted();
+      if (probes.some((p) => p?.binary)) return { kind: "binary" };
+      if (probes.some((p) => p?.tooLarge || (p?.size ?? 0) > PREVIEW_LIMIT)) return { kind: "tooLarge" };
+      const text = remote ? await call(commands.fsReadText(remote)) : "";
+      signal.throwIfAborted();
+      return {
+        kind: "text",
+        data: {
+          path: localPath(entry),
+          title: entry.path,
+          left: entry.local
+            ? { type: "file", path: localPath(entry), label: tx`Local: ${entry.path}` }
+            : { type: "text", text: "", label: tx("Local: (does not exist)") },
+          right: {
+            type: "text",
+            text,
+            label: `${server.name || server.id}: ${entry.remote ? entry.remotePath : tx("(does not exist)")}`,
+          },
+        },
+      };
+    },
+
+    /** Exact byte comparison, including binary files and line endings, in bounded reads. */
+    async equal(entry: SyncEntry, signal: AbortSignal): Promise<boolean> {
+      signal.throwIfAborted();
+      if (!entry.local || !entry.remote || entry.local.size !== entry.remote.size) return false;
+      const remote = await remoteSnapshot(entry);
+      signal.throwIfAborted();
+      // Read once for empty files too, to detect files changed since the listing.
+      for (let offset = 0; offset === 0 || offset < entry.local.size; offset += BLOCK_SIZE) {
+        signal.throwIfAborted();
+        const [a, b] = await Promise.all(
+          [localPath(entry), remote].map((path) => call(commands.fsReadRange(path, offset, BLOCK_SIZE))),
+        );
+        signal.throwIfAborted();
+        if (a!.total !== entry.local.size || b!.total !== entry.remote.size)
+          throw new Error("A file changed during comparison. Refresh and compare again.");
+        if (a!.data !== b!.data) return false;
+        if (entry.local.size === 0) break;
+      }
+      return true;
+    },
+  };
+}
+
+export type DeploymentComparison = ReturnType<typeof createDeploymentComparison>;
diff --git a/src/features/deployment/index.ts b/src/features/deployment/index.ts
index 314114393..e45ef8f32 100644
--- a/src/features/deployment/index.ts
+++ b/src/features/deployment/index.ts
@@ -15,6 +15,9 @@ import { autoUploadOn, registerDeploymentActions } from "./actions";
 import { DeploymentDialogs } from "./Dialogs";
 import { transferMenuEntries } from "./model";
 import { REMOTE_HOST_WINDOW, useDeployment } from "./store";
+import { installDeploymentEditorHost } from "./windowBridge";
+
+export { activateDeploymentWindow, DeploymentWindow } from "./window";
 
 /** Deployed URL of the path the last menu was prepared for. */
 let webUrlFor: { path: string; url: string | null } | null = null;
@@ -70,6 +73,7 @@ export function activate(): () => void {
     unsubFocus,
     unsubProject,
     registerDeploymentActions(),
+    installDeploymentEditorHost(),
     registerToolWindow({
       id: REMOTE_HOST_WINDOW,
       title: "Remote Host",
diff --git a/src/features/deployment/window.test.ts b/src/features/deployment/window.test.ts
new file mode 100644
index 000000000..fa3143533
--- /dev/null
+++ b/src/features/deployment/window.test.ts
@@ -0,0 +1,107 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useProject } from "@/platform/project";
+import { useDeployment } from "./store";
+import { DEFAULT_DEPLOYMENT_SERVER } from "@/platform/remoteSettings";
+
+const mocks = vi.hoisted(() => ({
+  launch: vi.fn(),
+  project: vi.fn(),
+  open: vi.fn(),
+  cancel: vi.fn(),
+  ask: vi.fn(),
+  error: vi.fn(),
+  dirty: vi.fn(),
+  save: vi.fn(),
+  dispose: vi.fn(),
+  destroy: vi.fn(),
+  close: vi.fn(),
+  title: vi.fn(),
+  emit: vi.fn(async () => {}),
+  closeRequested: null as null | ((event: { preventDefault(): void }) => Promise<void>),
+}));
+vi.mock("@tauri-apps/api/webviewWindow", () => ({
+  getCurrentWebviewWindow: () => ({
+    label: "deployment-project-2",
+    listen: async () => () => {},
+    onCloseRequested: async (callback: typeof mocks.closeRequested) => {
+      mocks.closeRequested = callback;
+      return () => {};
+    },
+    setTitle: mocks.title,
+    close: mocks.close,
+    destroy: mocks.destroy,
+  }),
+}));
+vi.mock("@/platform/ipc", () => ({
+  isTauri: () => true,
+  commands: { windowTakeLaunch: mocks.launch, projectCurrent: mocks.project },
+}));
+vi.mock("@tauri-apps/api/event", () => ({ emitTo: mocks.emit }));
+vi.mock("@/editor/core/embeddedDocuments", () => ({
+  activateEmbeddedDocuments: () => ({ dirty: mocks.dirty, save: mocks.save, dispose: mocks.dispose }),
+}));
+vi.mock("@/workbench/messages", () => ({ ask: mocks.ask, showError: mocks.error }));
+vi.mock("./actions", () => ({ openSync: mocks.open, closeSync: mocks.cancel }));
+vi.mock("./windowBridge", () => ({ openDeploymentSource: vi.fn() }));
+vi.mock("./Dialogs", () => ({ SecretDialog: () => null }));
+vi.mock("./SyncDialog", () => ({ SyncDialog: () => null }));
+vi.mock("@/workbench/OverlayHost", () => ({ OverlayHost: () => null }));
+vi.mock("@/workbench/TitleBar", () => ({ TitleBar: () => null }));
+
+import { activateDeploymentWindow } from "./window";
+
+let stop: (() => void) | undefined;
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.launch.mockResolvedValue(null);
+  mocks.dirty.mockReturnValue(false);
+  mocks.save.mockResolvedValue(undefined);
+  mocks.dispose.mockResolvedValue(undefined);
+  mocks.ask.mockResolvedValue({ button: "cancel" });
+  useProject.setState({ project: null, settings: { files: { autoSave: false } } as never });
+  useDeployment.setState({ sync: null });
+});
+afterEach(() => {
+  stop?.();
+  stop = undefined;
+});
+
+it("loads the parent project before comparing the launched server and local selection", async () => {
+  const server = { ...DEFAULT_DEPLOYMENT_SERVER, id: "s2", name: "Second project" };
+  const project = { root: "/second", settings: { deployment: { servers: [server] } } };
+  mocks.project.mockResolvedValue(project);
+  mocks.launch.mockResolvedValueOnce({ deployment: { server: "s2", paths: ["/second/a.php"] } });
+  mocks.open.mockImplementation(async () => useDeployment.setState({ sync: { server: "s2" } as never }));
+  stop = activateDeploymentWindow("project-2");
+  await vi.waitFor(() =>
+    expect(mocks.open).toHaveBeenCalledWith(expect.objectContaining({ id: "s2" }), ["/second/a.php"]),
+  );
+  expect(useProject.getState().project).toBe(project);
+});
+
+it("keeps the window and unsaved local edits when closing is cancelled or saving fails", async () => {
+  mocks.dirty.mockReturnValue(true);
+  stop = activateDeploymentWindow("project-2");
+  const event = { preventDefault: vi.fn() };
+  await mocks.closeRequested!(event);
+  expect(event.preventDefault).toHaveBeenCalled();
+  expect(mocks.save).not.toHaveBeenCalled();
+  expect(mocks.destroy).not.toHaveBeenCalled();
+  // The project window waiting to close stops.
+  expect(mocks.emit).toHaveBeenCalledWith(
+    "project-2",
+    "openidea://auxiliary/closed",
+    expect.objectContaining({ label: "deployment-project-2", closed: false }),
+  );
+  mocks.ask.mockResolvedValue({ button: "save" });
+  mocks.save.mockRejectedValueOnce(new Error("Disk full"));
+  await mocks.closeRequested!(event);
+  expect(mocks.error).toHaveBeenCalledWith("Cannot close deployment comparison", "Disk full");
+  expect(mocks.dispose).not.toHaveBeenCalled();
+  expect(mocks.destroy).not.toHaveBeenCalled();
+  await mocks.closeRequested!(event);
+  expect(mocks.cancel).toHaveBeenCalledOnce();
+  expect(mocks.dispose).toHaveBeenCalledOnce();
+  expect(mocks.destroy).toHaveBeenCalledOnce();
+  expect(mocks.save.mock.invocationCallOrder.at(-1)).toBeLessThan(mocks.destroy.mock.invocationCallOrder[0]!);
+});
diff --git a/src/features/deployment/window.tsx b/src/features/deployment/window.tsx
new file mode 100644
index 000000000..076febfad
--- /dev/null
+++ b/src/features/deployment/window.tsx
@@ -0,0 +1,187 @@
+/**
+ * The Sync with Deployed window (`deployment-<parent>`): one per project window, sharing that
+ * project's documents.
+ */
+import { useSyncExternalStore } from "react";
+import { emitTo } from "@tauri-apps/api/event";
+import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
+import { activateEmbeddedDocuments } from "@/editor/core/embeddedDocuments";
+import { AUX_CLOSED, type AuxCloseResult } from "@/platform/auxWindow";
+import { commands, type SyncStep } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { workflowSettings } from "@/platform/workflowSettings";
+import { isImeKey } from "@/platform/ime";
+import { useApplyTheme } from "@/workbench/theme";
+import { OverlayHost } from "@/workbench/OverlayHost";
+import { TitleBar } from "@/workbench/TitleBar";
+import { usePlatform } from "@/platform/platformInfo";
+import { WindowResizeHandles } from "@/workbench/WindowResizeHandles";
+import { provideEditorService } from "@/workbench/contributions";
+import { ask, showError } from "@/workbench/messages";
+import { Spinner, T, isPopupOpen } from "@/ui";
+import { closeSync, openSync } from "./actions";
+import { SecretDialog } from "./Dialogs";
+import { SyncDialog } from "./SyncDialog";
+import { patchSync, useDeployment } from "./store";
+import styles from "./Deployment.module.css";
+import { openDeploymentSource } from "./windowBridge";
+
+const LAUNCH_EVENT = "openidea://launch";
+
+let startupError: string | null = null;
+const startupListeners = new Set<() => void>();
+let saveSyncDocuments: ((steps: SyncStep[]) => Promise<void>) | undefined;
+const subscribeStartup = (listener: () => void) => {
+  startupListeners.add(listener);
+  return () => {
+    startupListeners.delete(listener);
+  };
+};
+function fail(error: unknown) {
+  if (useDeployment.getState().sync) {
+    patchSync({ error: error instanceof Error ? error.message : String(error) });
+    return;
+  }
+  startupError = error instanceof Error ? error.message : String(error);
+  startupListeners.forEach((listener) => listener());
+}
+
+export function activateDeploymentWindow(parent: string): () => void {
+  const native = getCurrentWebviewWindow();
+  const documents = activateEmbeddedDocuments();
+  provideEditorService({
+    openFile: (path, options) => openDeploymentSource(parent, path, options),
+    openInput: (input, options) => (input.path ? openDeploymentSource(parent, input.path, options) : Promise.resolve()),
+    activePath: () => null,
+    activeCursor: () => null,
+    saveAll: documents.save,
+  });
+  saveSyncDocuments = (steps) => {
+    const root = useProject.getState().project?.root;
+    return root
+      ? documents.savePaths(steps.map((step) => `${root.replace(/\/$/, "")}/${step.path}`))
+      : Promise.resolve();
+  };
+  let disposed = false;
+  let closing = false;
+  let queue = Promise.resolve();
+  const disposers: Array<() => void> = [];
+  // Tells the project window this window stays open, so it stops closing (see `closeDocumentWindows`).
+  const stayOpen = () => {
+    const result: AuxCloseResult = { label: native.label, closed: false, documents: [] };
+    void emitTo(parent, AUX_CLOSED, result).catch(() => {});
+  };
+  const listen = (ready: Promise<() => void>) => void ready.then((off) => (disposed ? off() : disposers.push(off)));
+  const launch = () => {
+    queue = queue
+      .then(async () => {
+        if (disposed || closing) return;
+        const pending = await commands.windowTakeLaunch();
+        if (!pending?.deployment) return;
+        if (useDeployment.getState().sync?.running) {
+          await showError(
+            "Deployment comparison",
+            "Wait for synchronization to finish before opening another comparison.",
+          );
+          return;
+        }
+        const project = await commands.projectCurrent();
+        if (!project) throw new Error("The project is no longer open.");
+        useProject.setState({ project, settings: project.settings });
+        const server = workflowSettings().deployment.servers.find((item) => item.id === pending.deployment!.server);
+        if (!server) throw new Error("The deployment server is no longer available.");
+        await native.setTitle(`Diff Between 'local files' and 'files on ${server.name || server.id}'`);
+        await openSync(server, pending.deployment.paths);
+        if (!useDeployment.getState().sync && !closing)
+          throw new Error("No selected files are mapped to this deployment server.");
+      })
+      .catch(fail);
+  };
+  listen(
+    native.listen(LAUNCH_EVENT, launch).then((off) => {
+      launch();
+      return off;
+    }),
+  );
+  listen(
+    native.onCloseRequested(async (event) => {
+      event.preventDefault();
+      if (closing) return;
+      closing = true;
+      try {
+        if (documents.dirty() && useProject.getState().settings?.files?.autoSave === false) {
+          const answer = await ask({
+            title: "Save local changes?",
+            body: "Save the local files edited in this comparison before closing.",
+            buttons: [{ id: "save", label: "Save and Close", primary: true }],
+          });
+          if (answer.button !== "save") return stayOpen();
+        }
+        await documents.save();
+        closeSync();
+        useDeployment.getState().secret?.resolve(null);
+        await documents.dispose();
+        await native.destroy();
+      } catch (error) {
+        stayOpen();
+        await showError("Cannot close deployment comparison", error instanceof Error ? error.message : String(error));
+      } finally {
+        closing = false;
+      }
+    }),
+  );
+  disposers.push(
+    useDeployment.subscribe((s, prev) => {
+      if (prev.sync && !s.sync && !closing) void native.close();
+    }),
+  );
+  const onKey = (event: KeyboardEvent) => {
+    if (event.defaultPrevented || isImeKey(event)) return;
+    if (
+      (event.key === "Escape" && !isPopupOpen()) ||
+      ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "w")
+    ) {
+      event.preventDefault();
+      void native.close();
+    } else if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "s") {
+      event.preventDefault();
+      void documents.save().catch(fail);
+    }
+  };
+  window.addEventListener("keydown", onKey);
+  disposers.push(() => window.removeEventListener("keydown", onKey));
+  return () => {
+    disposed = true;
+    saveSyncDocuments = undefined;
+    disposers.reverse().forEach((off) => off());
+  };
+}
+
+export function DeploymentWindow() {
+  useApplyTheme();
+  const sync = useDeployment((s) => s.sync);
+  const error = useSyncExternalStore(subscribeStartup, () => startupError);
+  const ownTitleBar = usePlatform((s) => s.overlayTitleBar || s.framelessTitleBar);
+  return (
+    <>
+      {sync ? (
+        <SyncDialog standalone beforeSynchronize={(steps) => saveSyncDocuments?.(steps) ?? Promise.resolve()} />
+      ) : (
+        <div className={styles.nativeWindow}>
+          {ownTitleBar && <TitleBar minimal title="Deployment Comparison" />}
+          <div className={styles.center} role={error ? "alert" : "status"}>
+            {error || (
+              <>
+                <Spinner />
+                <T>Opening deployment comparison…</T>
+              </>
+            )}
+          </div>
+        </div>
+      )}
+      <SecretDialog />
+      <OverlayHost />
+      <WindowResizeHandles />
+    </>
+  );
+}
diff --git a/src/features/deployment/windowBridge.ts b/src/features/deployment/windowBridge.ts
new file mode 100644
index 000000000..9dab0cde6
--- /dev/null
+++ b/src/features/deployment/windowBridge.ts
@@ -0,0 +1,40 @@
+import { emitTo } from "@tauri-apps/api/event";
+import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow";
+import { call, commands, isTauri } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { editorService, type OpenOptions } from "@/workbench/contributions";
+import { windowBackgroundHex } from "@/workbench/theme";
+
+const OPEN_SOURCE = "openidea://deployment/open-source";
+
+export function showDeploymentComparison(server: string, paths: string[]) {
+  return call(commands.windowOpenDeployment(server, paths, windowBackgroundHex()));
+}
+
+export function openDeploymentSource(parent: string, path: string, options?: OpenOptions) {
+  return emitTo(parent, OPEN_SOURCE, { path, options });
+}
+
+/** Jump to Source from the comparison opens the local file in its project's editor. */
+export function installDeploymentEditorHost(): () => void {
+  if (!isTauri()) return () => {};
+  let disposed = false;
+  let unlisten: (() => void) | undefined;
+  void getCurrentWebviewWindow()
+    .listen<{ path: string; options?: OpenOptions }>(OPEN_SOURCE, ({ payload }) => {
+      const root = useProject.getState().project?.root;
+      if (root && payload.path.startsWith(`${root}/`)) {
+        void editorService()
+          .openFile(payload.path, payload.options)
+          .then(() => getCurrentWebviewWindow().setFocus());
+      }
+    })
+    .then((off) => {
+      if (disposed) off();
+      else unlisten = off;
+    });
+  return () => {
+    disposed = true;
+    unlisten?.();
+  };
+}
diff --git a/src/features/index.ts b/src/features/index.ts
index 24df08c5f..ec4fa3c7f 100644
--- a/src/features/index.ts
+++ b/src/features/index.ts
@@ -12,7 +12,12 @@ import { activate as projectTree } from "./project-tree";
 import { activate as search } from "./search";
 import { activate as dependencies } from "./dependencies";
 import { activate as codeInsight } from "./code-insight";
-import { activate as vcs, activateComparisonWindow, activateSettingsPages as vcsPages } from "./vcs";
+import {
+  activate as vcs,
+  activateComparisonWindow,
+  activateDiffViewer,
+  activateSettingsPages as vcsPages,
+} from "./vcs";
 import { activate as terminal } from "./terminal";
 import { activate as run } from "./run";
 import { activate as runAnything } from "./run-anything";
@@ -39,7 +44,7 @@ import { activate as services } from "./services";
 import { activate as github } from "./github";
 import { activate as httpClient } from "./http-client";
 import { activate as database } from "./database";
-import { activate as deployment } from "./deployment";
+import { activate as deployment, activateDeploymentWindow } from "./deployment";
 import { activate as agents, activateSettingsPages as agentsPages } from "./agents";
 import { activate as vim, activateSettingsPages as vimPages } from "./vim";
 import { activate as ssh } from "./ssh";
@@ -109,6 +114,7 @@ export function activateFeatures(): () => void {
 
 export { SettingsWindow } from "./settings";
 export { ComparisonWindow } from "./vcs";
+export { DeploymentWindow } from "./deployment";
 
 /**
  * A comparison window of project window `parent`: the changed files between two revisions and
@@ -125,6 +131,19 @@ export function activateComparisonWindowFeatures(parent: string): () => void {
   ]);
 }
 
+/**
+ * The Sync with Deployed window of project window `parent`: local files next to their copies on a
+ * deployment server, with the diff viewer but no workbench.
+ */
+export function activateDeploymentWindowFeatures(parent: string): () => void {
+  return activateAll("deployment window", [
+    ["locale", appLocale],
+    ["settings", activateRuntimeSettings],
+    ["diff", activateDiffViewer],
+    ["deployment", () => activateDeploymentWindow(parent)],
+  ]);
+}
+
 /**
  * The native Settings window of project window `parent`: only the settings
  * pages (no workbench, project, editors or background services).
diff --git a/src/features/vcs/DiffEditor.tsx b/src/features/vcs/DiffEditor.tsx
index b00dd6e70..b1b83e2d0 100644
--- a/src/features/vcs/DiffEditor.tsx
+++ b/src/features/vcs/DiffEditor.tsx
@@ -217,7 +217,10 @@ export function DiffEditor({ input, toolbarActions }: { input: EditorInput; tool
   /** Text of the sides that are not live documents. */
   const [statics, setStatics] = useState<{ a: string | null; b: string | null } | null>(null);
   const [error, setError] = useState<string | null>(null);
-  const [opts, setOptsState] = useState<DiffViewOptions>(loadDiffOptions);
+  const [opts, setOptsState] = useState<DiffViewOptions>(() => {
+    const saved = loadDiffOptions();
+    return data.mode ? { ...saved, mode: data.mode } : saved;
+  });
   const [lang, setLang] = useState<Extension | null>(null);
   const [chunkInfo, setChunkInfo] = useState({ count: 0, current: -1, moves: 0, whitespaceOnly: false });
   const [busy, setBusy] = useState(false);
diff --git a/src/features/vcs/__tests__/diffToolbar.test.tsx b/src/features/vcs/__tests__/diffToolbar.test.tsx
index e7f1e33d4..bdac8d2e6 100644
--- a/src/features/vcs/__tests__/diffToolbar.test.tsx
+++ b/src/features/vcs/__tests__/diffToolbar.test.tsx
@@ -71,6 +71,14 @@ beforeEach(() => {
 });
 
 describe("Diff toolbar", () => {
+  it("can start an embedded comparison side by side without overwriting saved viewer preferences", async () => {
+    localStorage.setItem("openidea.vcs.diffOptions", JSON.stringify({ mode: "unified" }));
+    const mounted = render(<DiffEditor input={{ ...input, data: { ...(input.data as object), mode: "split" } }} />);
+    await waitFor(() => expect(mounted.container.querySelectorAll(".cm-editor")).toHaveLength(2));
+    expect(JSON.parse(localStorage.getItem("openidea.vcs.diffOptions")!).mode).toBe("unified");
+    mounted.unmount();
+    localStorage.removeItem("openidea.vcs.diffOptions");
+  });
   it("shows a binary notice for disk comparisons instead of identical empty text", async () => {
     probe.mockResolvedValue({ status: "ok", data: { size: 3, binary: true, tooLarge: false } });
     const binaryInput = {
diff --git a/src/features/vcs/diff-editor-tab.tsx b/src/features/vcs/diff-editor-tab.tsx
index 12f19afb8..5f9779a8e 100644
--- a/src/features/vcs/diff-editor-tab.tsx
+++ b/src/features/vcs/diff-editor-tab.tsx
@@ -3,9 +3,11 @@ import { hideAllToolWindows, useToolWindowLayout } from "@/workbench/toolwindows
 import { shortcutLabel } from "@/platform/keymap";
 import { IconButton } from "@/ui";
 import { DiffEditor } from "./DiffEditor";
+import type { DiffData } from "./diffInput";
 
 export function DiffEditorTab({ input }: { input: EditorInput }) {
   const maximized = useToolWindowLayout((state) => !!state.stashed && !Object.values(state.visible).some(Boolean));
+  if ((input.data as DiffData).embedded) return <DiffEditor input={input} />;
   return (
     <DiffEditor
       input={input}
diff --git a/src/features/vcs/diffInput.ts b/src/features/vcs/diffInput.ts
index 861bc7145..cea3a56da 100644
--- a/src/features/vcs/diffInput.ts
+++ b/src/features/vcs/diffInput.ts
@@ -55,6 +55,10 @@ export interface DiffData {
    * pull request's file: `{ kind: "github.pullRequest", number: 12, path: "src/a.ts" }`. Plain JSON.
    */
   context?: { kind: string; [key: string]: unknown };
+  /** Shown inside another view (deployment comparison), not as an editor tab: no tab controls. */
+  embedded?: boolean;
+  /** Show the sides this way at first instead of the saved mode, which it leaves unchanged. */
+  mode?: "split" | "unified";
 }
 
 export const DIFF_KIND = "diff";
diff --git a/src/features/vcs/index.ts b/src/features/vcs/index.ts
index 703f3172d..521828c10 100644
--- a/src/features/vcs/index.ts
+++ b/src/features/vcs/index.ts
@@ -149,6 +149,16 @@ function conflictsBody(names: string[]): string {
 /** Settings › Version Control › Log (also used by the Settings window). */
 export { activateComparisonWindow, ComparisonWindow } from "./ComparisonWindow";
 
+/** The diff viewer (editor kind `diff`), also for windows that show diffs without Git (deployment). */
+export function activateDiffViewer(): () => void {
+  return registerEditorKind({
+    kind: DIFF_KIND,
+    component: lazyComponent(() => import("./diff-editor-tab").then((m) => m.DiffEditorTab)),
+    title: (input) => diffTitle(input.data as DiffData),
+    icon: () => "diff",
+  });
+}
+
 export function activateSettingsPages(): () => void {
   return registerSettingsPage({
     id: "vcs.log",
@@ -230,12 +240,7 @@ export function activate(): () => void {
       component: lazyComponent(() => import("./GitLog").then((m) => m.GitToolWindow)),
       headerContent: lazyComponent(() => import("./GitLog").then((m) => m.GitTabs)),
     }),
-    registerEditorKind({
-      kind: DIFF_KIND,
-      component: lazyComponent(() => import("./diff-editor-tab").then((m) => m.DiffEditorTab)),
-      title: (input) => diffTitle(input.data as DiffData),
-      icon: () => "diff",
-    }),
+    activateDiffViewer(),
     registerEditorKind({
       kind: MERGE_KIND,
       component: lazyComponent(() => import("./MergeEditor").then((m) => m.MergeEditor)),
diff --git a/src/main.tsx b/src/main.tsx
index cb709b39a..aa0490b42 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -5,9 +5,11 @@ import { Workbench } from "./workbench/Workbench";
 import { activateSecondaryWindow, activateWorkbench } from "./workbench/activate";
 import {
   activateComparisonWindowFeatures,
+  activateDeploymentWindowFeatures,
   activateFeatures,
   activateSettingsWindowFeatures,
   ComparisonWindow,
+  DeploymentWindow,
   SettingsWindow,
 } from "./features";
 import { auxiliaryWindow } from "./platform/auxWindow";
@@ -28,7 +30,8 @@ if (import.meta.env.DEV && isTauri()) {
 installRepeatedDoubleClick();
 installErrorLogging();
 
-// Auxiliary windows (Settings `settings-<parent>`, comparisons `comparison-<parent>-<n>`) load this page too.
+// Auxiliary windows (Settings `settings-<parent>`, comparisons `comparison-<parent>-<n>`, Sync with
+// Deployed `deployment-<parent>`) load this page too.
 const aux = auxiliaryWindow();
 
 if (aux?.kind === "settings") {
@@ -38,6 +41,9 @@ if (aux?.kind === "settings") {
   activateSecondaryWindow();
   activateComparisonWindowFeatures(aux.parent);
   installKeyboardDispatcher();
+} else if (aux?.kind === "deployment") {
+  activateSecondaryWindow();
+  activateDeploymentWindowFeatures(aux.parent);
 } else {
   activateWorkbench();
   // `vite build --mode perf` is a production bundle for the performance harness (`perf/`).
@@ -58,7 +64,15 @@ if (aux?.kind === "settings") {
 
 ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
   <React.StrictMode>
-    {aux?.kind === "settings" ? <SettingsWindow /> : aux?.kind === "comparison" ? <ComparisonWindow /> : <Workbench />}
+    {aux?.kind === "settings" ? (
+      <SettingsWindow />
+    ) : aux?.kind === "comparison" ? (
+      <ComparisonWindow />
+    ) : aux?.kind === "deployment" ? (
+      <DeploymentWindow />
+    ) : (
+      <Workbench />
+    )}
   </React.StrictMode>,
 );
 hideSplash();
diff --git a/src/platform/auxWindow.test.ts b/src/platform/auxWindow.test.ts
index 273566643..1eca833f2 100644
--- a/src/platform/auxWindow.test.ts
+++ b/src/platform/auxWindow.test.ts
@@ -7,6 +7,7 @@ describe("auxiliaryWindow", () => {
     expect(auxiliaryWindow("settings-project-2")).toEqual({ kind: "settings", parent: "project-2" });
     expect(auxiliaryWindow("comparison-main-0")).toEqual({ kind: "comparison", parent: "main" });
     expect(auxiliaryWindow("comparison-project-2-14")).toEqual({ kind: "comparison", parent: "project-2" });
+    expect(auxiliaryWindow("deployment-project-2")).toEqual({ kind: "deployment", parent: "project-2" });
   });
 
   it("leaves project windows and malformed labels alone", () => {
diff --git a/src/platform/auxWindow.ts b/src/platform/auxWindow.ts
index 24a5b1f1e..15d95c3b5 100644
--- a/src/platform/auxWindow.ts
+++ b/src/platform/auxWindow.ts
@@ -1,5 +1,5 @@
 /**
- * Auxiliary windows: Settings and comparison windows that belong
+ * Auxiliary windows: Settings, comparison and deployment windows that belong
  * to a project window (their parent) and share its project. Labels name the
  * kind and the parent (`settings-main`, `comparison-project-2-3`), mirroring
  * `windows::auxiliary` in src-tauri/src/windows.rs.
@@ -8,11 +8,11 @@ import { getAllWindows, getCurrentWindow } from "@tauri-apps/api/window";
 import { TauriEvent } from "@tauri-apps/api/event";
 import { isTauri } from "./ipc";
 
-export type AuxKind = "settings" | "comparison";
+export type AuxKind = "settings" | "comparison" | "deployment";
 
 /** Kinds with several windows per parent (`<kind>-<parent>-<n>`); the others have one (`<kind>-<parent>`). */
 const MULTIPLE: ReadonlySet<AuxKind> = new Set(["comparison"]);
-const KINDS: readonly AuxKind[] = ["settings", "comparison"];
+const KINDS: readonly AuxKind[] = ["settings", "comparison", "deployment"];
 
 /** An auxiliary window reports to its parent whether it closed, and which documents it released. */
 export const AUX_CLOSED = "openidea://auxiliary/closed";
diff --git a/src/platform/locales/actionTitles.test.ts b/src/platform/locales/actionTitles.test.ts
index 18274c970..2af3d22f4 100644
--- a/src/platform/locales/actionTitles.test.ts
+++ b/src/platform/locales/actionTitles.test.ts
@@ -4,7 +4,7 @@ import ts from "typescript";
 import { expect, it } from "vitest";
 import zh from "./text/zh.json";
 
-const root = fileURLToPath(new URL("../../../", import.meta.url));
+const root = fileURLToPath(new URL("../../../", import.meta.url)).replaceAll("\\", "/");
 const config = ts.readConfigFile(`${root}tsconfig.json`, ts.sys.readFile);
 const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, root);
 const program = ts.createProgram(parsed.fileNames, parsed.options);
diff --git a/src/platform/locales/text/fr.json b/src/platform/locales/text/fr.json
index 64a26e97c..2cc108f62 100644
--- a/src/platform/locales/text/fr.json
+++ b/src/platform/locales/text/fr.json
@@ -4284,24 +4284,15 @@
   "Delete {n} items from the server?": "Supprimer {n} éléments du serveur ?",
   "Not mapped to a project path": "Non associé à un chemin du projet",
   "Unknown Host Key": "Clé d'hôte inconnue",
-  "Sync with {server}": "Synchroniser avec {server}",
-  "Hide identical files ({n})": "Masquer les fichiers identiques ({n})",
-  "Synchronize": "Synchroniser",
   "{n} of {total} files will change": "{n} fichiers sur {total} seront modifiés",
   "Comparing local and remote files…": "Comparaison des fichiers locaux et distants…",
   "Files to synchronize": "Fichiers à synchroniser",
   "Action": "Action",
-  "Local size": "Taille locale",
-  "Local modified": "Modification locale",
-  "Remote size": "Taille distante",
-  "Remote modified": "Modification distante",
-  "Local and remote files are identical": "Les fichiers locaux et distants sont identiques",
   "Synchronizing…": "Synchronisation…",
   "Local only": "Local uniquement",
   "Remote only": "Distant uniquement",
   "Local is newer": "Le local est plus récent",
   "Remote is newer": "Le distant est plus récent",
-  "Different size": "Taille différente",
   "Identical": "Identique",
   "Upload": "Envoyer",
   "Delete remote": "Supprimer le distant",
diff --git a/src/platform/locales/text/ko.json b/src/platform/locales/text/ko.json
index 18d7826c5..e95c258ce 100644
--- a/src/platform/locales/text/ko.json
+++ b/src/platform/locales/text/ko.json
@@ -4395,24 +4395,15 @@
   "Delete {n} items from the server?": "서버에서 항목 {n}개를 삭제하시겠습니까?",
   "Not mapped to a project path": "프로젝트 경로에 매핑되지 않음",
   "Unknown Host Key": "알 수 없는 호스트 키",
-  "Sync with {server}": "{server}와(과) 동기화",
-  "Hide identical files ({n})": "동일한 파일 숨기기({n})",
-  "Synchronize": "동기화",
   "{n} of {total} files will change": "파일 {total}개 중 {n}개가 변경됩니다",
   "Comparing local and remote files…": "로컬 파일과 원격 파일 비교 중…",
   "Files to synchronize": "동기화할 파일",
   "Action": "액션",
-  "Local size": "로컬 크기",
-  "Local modified": "로컬 수정 시간",
-  "Remote size": "원격 크기",
-  "Remote modified": "원격 수정 시간",
-  "Local and remote files are identical": "로컬 파일과 원격 파일이 동일합니다",
   "Synchronizing…": "동기화 중…",
   "Local only": "로컬에만 있음",
   "Remote only": "원격에만 있음",
   "Local is newer": "로컬이 더 최신임",
   "Remote is newer": "원격이 더 최신임",
-  "Different size": "크기가 다름",
   "Identical": "동일함",
   "Upload": "업로드",
   "Delete remote": "원격 삭제",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 4f4ff1edf..3ac83fd51 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -4407,24 +4407,15 @@
   "Delete {n} items from the server?": "要从服务器删除 {n} 个项目吗？",
   "Not mapped to a project path": "未映射到项目路径",
   "Unknown Host Key": "未知的主机密钥",
-  "Sync with {server}": "与 {server} 同步",
-  "Hide identical files ({n})": "隐藏相同的文件（{n}）",
-  "Synchronize": "同步",
   "{n} of {total} files will change": "{total} 个文件中有 {n} 个将被更改",
   "Comparing local and remote files…": "正在比较本地和远程文件…",
   "Files to synchronize": "要同步的文件",
   "Action": "操作",
-  "Local size": "本地大小",
-  "Local modified": "本地修改时间",
-  "Remote size": "远程大小",
-  "Remote modified": "远程修改时间",
-  "Local and remote files are identical": "本地和远程文件相同",
   "Synchronizing…": "正在同步…",
   "Local only": "仅本地",
   "Remote only": "仅远程",
   "Local is newer": "本地较新",
   "Remote is newer": "远程较新",
-  "Different size": "大小不同",
   "Identical": "相同",
   "Upload": "上传",
   "Delete remote": "删除远程",
@@ -5720,6 +5711,46 @@
   "The account's 5-hour and weekly limits, when the agent reports them (Claude Code)": "账户的 5 小时和每周限额，在智能体报告时显示（Claude Code）",
   "Session cost": "会话花费",
   "What the session has cost so far, as the agent reports it (API pricing, also shown on subscriptions)": "智能体报告的本会话目前花费（按 API 价格计算，订阅账户也会显示）",
+  "Local: {path}": "本地：{path}",
+  "Local: (does not exist)": "本地：（不存在）",
+  "Synchronize All": "同步全部",
+  "Deployment comparison options": "部署比较选项",
+  "Refresh comparison": "刷新比较",
+  "Show local-only files": "显示仅本地存在的文件",
+  "Show different files": "显示有差异的文件",
+  "Show remote-only files": "显示仅远程存在的文件",
+  "Compare by:": "比较依据：",
+  "Compare by": "比较依据",
+  "Size and Timestamp": "大小和时间戳",
+  "Binary Content": "二进制内容",
+  "Synchronize Selected": "同步所选文件",
+  "Stop content comparison": "停止内容比较",
+  "Filter:": "筛选：",
+  "Local files": "本地文件",
+  "Local name": "本地名称",
+  "Remote name": "远程名称",
+  "Space changes the selected operation. Enter synchronizes the selected file. Synchronize All applies all chosen operations.": "空格键切换所选操作，Enter 键同步所选文件。“同步全部”执行所有已选择的操作。",
+  "Resize file list and diff preview": "调整文件列表和差异预览的大小",
+  "The deployment server or project is no longer available": "部署服务器或项目已不可用",
+  "Select a file to compare its contents": "选择文件以比较其内容",
+  "Loading file contents…": "正在加载文件内容…",
+  "This file is too large for the text preview. Use Binary Content to compare it.": "此文件过大，无法进行文本预览。请使用“二进制内容”比较。",
+  "Deployment comparison": "部署比较",
+  "Wait for synchronization to finish before opening another comparison.": "请等待同步完成后再打开其他比较。",
+  "Save local changes?": "保存本地更改？",
+  "Save the local files edited in this comparison before closing.": "关闭前保存本次比较中编辑的本地文件。",
+  "Save and Close": "保存并关闭",
+  "Cannot close deployment comparison": "无法关闭部署比较",
+  "Deployment Comparison": "部署比较",
+  "Opening deployment comparison…": "正在打开部署比较…",
+  "Diff Between 'local files' and 'files on {server}'": "本地文件与“{server}”上的文件的差异",
+  "Comparing contents: {done} of {total}": "正在比较内容：{done}/{total}",
+  "A file changed during comparison. Refresh and compare again.": "比较期间文件已更改，请刷新后重新比较。",
+  "The project is no longer open.": "项目已关闭。",
+  "The deployment server is no longer available.": "部署服务器已不可用。",
+  "No selected files are mapped to this deployment server.": "所选文件均未映射到此部署服务器。",
+  "Cannot open comparison for {server}": "无法打开与 {server} 的比较",
+  "Could not refresh comparison: {error}": "无法刷新比较：{error}",
   "Build and run using": "构建和运行使用",
   "Gradle runs a main class as a JavaExec task on its source set's runtime classpath (Gradle's resource processing included). OpenIDEA launches it on the Java language server's classpath.": "Gradle 以 JavaExec 任务在源集的运行时类路径上运行主类（包括 Gradle 的资源处理）。OpenIDEA 在 Java 语言服务器的类路径上启动它。",
   "Set an absolute root path on the Connection tab first": "请先在“连接”页设置绝对根路径",