From 0657d619dfb7190c0449697e1e5512a57f0ad95a Mon Sep 17 00:00:00 2001
From: Nate Bross <nate@brosstribe.com>
Date: Tue, 19 May 2026 21:37:09 -0500
Subject: [PATCH] fix: make paste deduplication name-aware

Paste collisions used to be content-only: pasting a clip whose XML
matched any existing clip was silently skipped, regardless of name.
This broke variant tracking (paste, rename, repaste leaves the user
with only the renamed copy).

Dedup now keys on (name, folder). Same name + same content skips as
a true duplicate. Different name + same content lands as a variant.
Same name + different content prompts the user via a new
IClipCollisionPrompt with Replace / Keep both / Cancel choices and
an apply-to-all option for batch (group) pastes.
---
 src/SharpFM/App.axaml.cs                      |   4 +-
 src/SharpFM/Dialogs/ClipCollisionDialog.axaml |  57 +++++++
 .../Dialogs/ClipCollisionDialog.axaml.cs      |  60 +++++++
 src/SharpFM/Dialogs/IClipCollisionPrompt.cs   |  30 ++++
 .../Dialogs/NullClipCollisionPrompt.cs        |  17 ++
 .../Dialogs/WindowClipCollisionPrompt.cs      |  17 ++
 src/SharpFM/ViewModels/MainWindowViewModel.cs |  90 +++++++---
 .../ViewModels/MainWindowViewModelTests.cs    | 159 +++++++++++++++++-
 8 files changed, 407 insertions(+), 27 deletions(-)
 create mode 100644 src/SharpFM/Dialogs/ClipCollisionDialog.axaml
 create mode 100644 src/SharpFM/Dialogs/ClipCollisionDialog.axaml.cs
 create mode 100644 src/SharpFM/Dialogs/IClipCollisionPrompt.cs
 create mode 100644 src/SharpFM/Dialogs/NullClipCollisionPrompt.cs
 create mode 100644 src/SharpFM/Dialogs/WindowClipCollisionPrompt.cs

diff --git a/src/SharpFM/App.axaml.cs b/src/SharpFM/App.axaml.cs
index 211c402..2c7efb2 100644
--- a/src/SharpFM/App.axaml.cs
+++ b/src/SharpFM/App.axaml.cs
@@ -43,11 +43,13 @@ public override void OnFrameworkInitializationCompleted()
             Services = services.BuildServiceProvider();
 
             var inputPrompt = new WindowInputPrompt(desktop.MainWindow);
+            var collisionPrompt = new WindowClipCollisionPrompt(desktop.MainWindow);
             var viewModel = new MainWindowViewModel(
                 logger,
                 Services.GetRequiredService<IClipboardService>(),
                 Services.GetRequiredService<IFolderService>(),
-                inputPrompt);
+                inputPrompt,
+                collisionPrompt);
 
             // Load plugins
             var pluginHost = new PluginHost(viewModel, loggerFactory, inputPrompt);
diff --git a/src/SharpFM/Dialogs/ClipCollisionDialog.axaml b/src/SharpFM/Dialogs/ClipCollisionDialog.axaml
new file mode 100644
index 0000000..34e0aed
--- /dev/null
+++ b/src/SharpFM/Dialogs/ClipCollisionDialog.axaml
@@ -0,0 +1,57 @@
+<Window
+    x:Class="SharpFM.Dialogs.ClipCollisionDialog"
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    Title="Clip already exists"
+    Width="460"
+    SizeToContent="Height"
+    WindowStartupLocation="CenterOwner">
+
+    <Grid Margin="16" RowDefinitions="Auto,Auto,Auto,Auto">
+
+        <TextBlock
+            x:Name="messageLabel"
+            Grid.Row="0"
+            Margin="0,0,0,8"
+            Classes="Fluent2Body"
+            Text=""
+            TextWrapping="Wrap" />
+
+        <TextBlock
+            x:Name="locationLabel"
+            Grid.Row="1"
+            Margin="0,0,0,12"
+            Classes="Fluent2Body"
+            FontStyle="Italic"
+            Text=""
+            TextWrapping="Wrap" />
+
+        <CheckBox
+            x:Name="applyToAllBox"
+            Grid.Row="2"
+            Margin="0,0,0,12"
+            Content="Apply to all remaining clips in this paste" />
+
+        <StackPanel
+            Grid.Row="3"
+            HorizontalAlignment="Right"
+            Orientation="Horizontal"
+            Spacing="8">
+            <Button
+                x:Name="cancelButton"
+                Classes="Fluent2"
+                Content="Cancel" />
+            <Button
+                x:Name="keepBothButton"
+                Classes="Fluent2"
+                Content="Keep both" />
+            <Button
+                x:Name="replaceButton"
+                Classes="Fluent2Primary"
+                Content="Replace"
+                IsDefault="True" />
+        </StackPanel>
+
+    </Grid>
+
+</Window>
diff --git a/src/SharpFM/Dialogs/ClipCollisionDialog.axaml.cs b/src/SharpFM/Dialogs/ClipCollisionDialog.axaml.cs
new file mode 100644
index 0000000..bf11d8f
--- /dev/null
+++ b/src/SharpFM/Dialogs/ClipCollisionDialog.axaml.cs
@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace SharpFM.Dialogs;
+
+/// <summary>
+/// Modal that asks the user how to resolve a paste collision (same name,
+/// different XML). Production <see cref="IClipCollisionPrompt"/> opens this
+/// over the main window; tests use a fake prompt and never construct this.
+/// </summary>
+[ExcludeFromCodeCoverage]
+public partial class ClipCollisionDialog : Window
+{
+    private readonly TextBlock _messageLabel;
+    private readonly TextBlock _locationLabel;
+    private readonly CheckBox _applyToAllBox;
+
+    public ClipCollisionDecision Result { get; private set; } =
+        new(ClipCollisionChoice.Cancel, ApplyToAll: false);
+
+    public ClipCollisionDialog()
+    {
+        AvaloniaXamlLoader.Load(this);
+        _messageLabel = this.FindControl<TextBlock>("messageLabel")!;
+        _locationLabel = this.FindControl<TextBlock>("locationLabel")!;
+        _applyToAllBox = this.FindControl<CheckBox>("applyToAllBox")!;
+
+        this.FindControl<Button>("replaceButton")!.Click += (_, _) => Finish(ClipCollisionChoice.Replace);
+        this.FindControl<Button>("keepBothButton")!.Click += (_, _) => Finish(ClipCollisionChoice.KeepBoth);
+        this.FindControl<Button>("cancelButton")!.Click += (_, _) => Finish(ClipCollisionChoice.Cancel);
+    }
+
+    private void Finish(ClipCollisionChoice choice)
+    {
+        Result = new ClipCollisionDecision(choice, _applyToAllBox.IsChecked == true);
+        Close();
+    }
+
+    public void Configure(string clipName, IReadOnlyList<string> folderPath)
+    {
+        _messageLabel.Text = $"A clip named \"{clipName}\" already exists with different content.";
+        _locationLabel.Text = folderPath.Count == 0
+            ? "Location: (root)"
+            : $"Location: {string.Join(" / ", folderPath)}";
+    }
+
+    public static async Task<ClipCollisionDecision> PromptAsync(
+        Window owner,
+        string clipName,
+        IReadOnlyList<string> folderPath)
+    {
+        var window = new ClipCollisionDialog();
+        window.Configure(clipName, folderPath);
+        await window.ShowDialog(owner);
+        return window.Result;
+    }
+}
diff --git a/src/SharpFM/Dialogs/IClipCollisionPrompt.cs b/src/SharpFM/Dialogs/IClipCollisionPrompt.cs
new file mode 100644
index 0000000..7920873
--- /dev/null
+++ b/src/SharpFM/Dialogs/IClipCollisionPrompt.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace SharpFM.Dialogs;
+
+/// <summary>How the user wants to resolve a same-name + different-content paste collision.</summary>
+public enum ClipCollisionChoice
+{
+    /// <summary>Skip the incoming clip and abort the remainder of the paste batch.</summary>
+    Cancel,
+    /// <summary>Overwrite the existing clip with the incoming XML.</summary>
+    Replace,
+    /// <summary>Add the incoming clip alongside the existing one with a unique suffix.</summary>
+    KeepBoth,
+}
+
+/// <summary>Result of <see cref="IClipCollisionPrompt.PromptAsync"/>.</summary>
+/// <param name="Choice">The action selected by the user.</param>
+/// <param name="ApplyToAll">When true, reuse this choice for the remainder of the paste batch.</param>
+public sealed record ClipCollisionDecision(ClipCollisionChoice Choice, bool ApplyToAll);
+
+/// <summary>
+/// Host-supplied prompt for resolving paste collisions where a clip with the
+/// same name already exists in the target folder but holds different XML.
+/// Mirrors <see cref="IInputPrompt"/>'s test-friendly abstraction.
+/// </summary>
+public interface IClipCollisionPrompt
+{
+    Task<ClipCollisionDecision> PromptAsync(string clipName, IReadOnlyList<string> folderPath);
+}
diff --git a/src/SharpFM/Dialogs/NullClipCollisionPrompt.cs b/src/SharpFM/Dialogs/NullClipCollisionPrompt.cs
new file mode 100644
index 0000000..b185822
--- /dev/null
+++ b/src/SharpFM/Dialogs/NullClipCollisionPrompt.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace SharpFM.Dialogs;
+
+/// <summary>
+/// Default <see cref="IClipCollisionPrompt"/> for environments without a UI
+/// thread (headless tests, legacy view-model ctor path). Returns
+/// <see cref="ClipCollisionChoice.Cancel"/> so a collision in a non-interactive
+/// context aborts the rest of the paste instead of silently mutating existing
+/// clips.
+/// </summary>
+public sealed class NullClipCollisionPrompt : IClipCollisionPrompt
+{
+    public Task<ClipCollisionDecision> PromptAsync(string clipName, IReadOnlyList<string> folderPath) =>
+        Task.FromResult(new ClipCollisionDecision(ClipCollisionChoice.Cancel, ApplyToAll: false));
+}
diff --git a/src/SharpFM/Dialogs/WindowClipCollisionPrompt.cs b/src/SharpFM/Dialogs/WindowClipCollisionPrompt.cs
new file mode 100644
index 0000000..c9e32c6
--- /dev/null
+++ b/src/SharpFM/Dialogs/WindowClipCollisionPrompt.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+
+namespace SharpFM.Dialogs;
+
+/// <summary>
+/// Production <see cref="IClipCollisionPrompt"/>. Opens a
+/// <see cref="ClipCollisionDialog"/> modal over the supplied owner window.
+/// </summary>
+[ExcludeFromCodeCoverage]
+public sealed class WindowClipCollisionPrompt(Window owner) : IClipCollisionPrompt
+{
+    public Task<ClipCollisionDecision> PromptAsync(string clipName, IReadOnlyList<string> folderPath) =>
+        ClipCollisionDialog.PromptAsync(owner, clipName, folderPath);
+}
diff --git a/src/SharpFM/ViewModels/MainWindowViewModel.cs b/src/SharpFM/ViewModels/MainWindowViewModel.cs
index 8026dbc..cadb567 100644
--- a/src/SharpFM/ViewModels/MainWindowViewModel.cs
+++ b/src/SharpFM/ViewModels/MainWindowViewModel.cs
@@ -28,6 +28,7 @@ public partial class MainWindowViewModel : INotifyPropertyChanged
     private readonly IClipboardService _clipboard;
     private readonly IFolderService _folderService;
     private readonly IInputPrompt _prompt;
+    private readonly IClipCollisionPrompt _collisionPrompt;
     private readonly DispatcherTimer _statusTimer;
     private IClipRepository _repository;
     private OpenTabViewModel? _trackedActiveTab;
@@ -83,12 +84,14 @@ public MainWindowViewModel(
         ILogger logger,
         IClipboardService clipboard,
         IFolderService folderService,
-        IInputPrompt? prompt = null)
+        IInputPrompt? prompt = null,
+        IClipCollisionPrompt? collisionPrompt = null)
     {
         _logger = logger;
         _clipboard = clipboard;
         _folderService = folderService;
         _prompt = prompt ?? new NullInputPrompt();
+        _collisionPrompt = collisionPrompt ?? new NullClipCollisionPrompt();
 
         _statusTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(3) };
         _statusTimer.Tick += (_, _) =>
@@ -448,22 +451,25 @@ public async Task PasteFileMakerClipData()
                 (ClipTypeRegistry.IsRegistered(format) ? recognized : unrecognized).Add(format);
             }
 
+            var batch = new PasteBatchState();
+
             foreach (var format in recognized)
             {
-                var (added, last) = await PasteOneFormat(format, pasteRoot);
+                var (added, last) = await PasteOneFormat(format, pasteRoot, batch);
                 lastAdded = last ?? lastAdded;
                 count += added;
+                if (batch.Cancelled) break;
             }
 
             // Fall back to opaque only when no recognized format produced a
             // paste — same payload often arrives in both a known and a
             // not-yet-registered encoding, and the known one already covered it.
             string? unknownFormatPasted = null;
-            if (count == 0)
+            if (count == 0 && !batch.Cancelled)
             {
                 foreach (var format in unrecognized)
                 {
-                    var (added, last) = await PasteOneFormat(format, pasteRoot);
+                    var (added, last) = await PasteOneFormat(format, pasteRoot, batch);
                     if (added == 0) continue;
                     lastAdded = last ?? lastAdded;
                     count += added;
@@ -484,6 +490,10 @@ public async Task PasteFileMakerClipData()
             {
                 ShowStatus($"Pasted unknown format {unknownFormatPasted}; will round-trip as raw XML.");
             }
+            else if (batch.Cancelled)
+            {
+                ShowStatus($"Paste cancelled at name collision; kept {count} clip(s)", isError: true);
+            }
             else
             {
                 ShowStatus(count > 0 ? $"Pasted {count} clip(s) from FileMaker" : "No FileMaker clips found on clipboard");
@@ -496,7 +506,10 @@ public async Task PasteFileMakerClipData()
         }
     }
 
-    private async Task<(int added, ClipViewModel? last)> PasteOneFormat(string format, IReadOnlyList<string> pasteRoot)
+    private async Task<(int added, ClipViewModel? last)> PasteOneFormat(
+        string format,
+        IReadOnlyList<string> pasteRoot,
+        PasteBatchState batch)
     {
         object? clipData = await _clipboard.GetDataAsync(format);
         if (clipData is not byte[] dataObj) return (0, null);
@@ -516,33 +529,64 @@ public async Task PasteFileMakerClipData()
 
             foreach (var entry in decomposed.Entries)
             {
-                var entryClip = Clip.FromXml("new-clip", format, entry.Xml);
-                if (FileMakerClips.Any(k => k.Clip.Xml == entryClip.Xml &&
-                    FolderPathsEqual(k.FolderPath, Combine(pasteRoot, entry.FolderPath))))
-                {
-                    continue;
-                }
-
+                if (batch.Cancelled) break;
                 var folderPath = Combine(pasteRoot, entry.FolderPath);
-                entryClip = entryClip.Rename(UniqueClipName(entry.Name, folderPath));
-
-                last = new ClipViewModel(entryClip) { FolderPath = folderPath };
-                FileMakerClips.Add(last);
+                var entryClip = Clip.FromXml(entry.Name, format, entry.Xml);
+                var result = await TryPasteEntry(entry.Name, folderPath, entryClip, batch);
+                if (result is null) continue;
+                last = result;
                 added++;
             }
             return (added, last);
         }
 
-        // don't add duplicates
-        if (FileMakerClips.Any(k => k.Clip.Xml == rawClip.Xml)) return (0, null);
-
         var sourceName = ClipTypeRegistry.For(format).TryGetSourceName(rawClip.Xml);
         var desired = string.IsNullOrWhiteSpace(sourceName) ? "new-clip" : sourceName;
-        var singleClip = rawClip.Rename(UniqueClipName(desired, pasteRoot));
+        var single = await TryPasteEntry(desired, pasteRoot, rawClip, batch);
+        return single is null ? (0, null) : (1, single);
+    }
+
+    private async Task<ClipViewModel?> TryPasteEntry(
+        string name,
+        IReadOnlyList<string> folderPath,
+        Clip clip,
+        PasteBatchState batch)
+    {
+        var existing = FileMakerClips.FirstOrDefault(c =>
+            c.Clip.Name == name && FolderPathsEqual(c.FolderPath, folderPath));
 
-        last = new ClipViewModel(singleClip) { FolderPath = pasteRoot };
-        FileMakerClips.Add(last);
-        return (1, last);
+        if (existing is not null)
+        {
+            if (existing.Clip.Xml == clip.Xml) return null;
+
+            var decision = batch.StickyDecision
+                ?? await _collisionPrompt.PromptAsync(name, folderPath);
+            if (decision.ApplyToAll) batch.StickyDecision = decision;
+
+            switch (decision.Choice)
+            {
+                case ClipCollisionChoice.Cancel:
+                    batch.Cancelled = true;
+                    return null;
+                case ClipCollisionChoice.Replace:
+                    existing.Replace(clip.Xml);
+                    return existing;
+                case ClipCollisionChoice.KeepBoth:
+                    // fall through to the rename-and-add path below
+                    break;
+            }
+        }
+
+        var renamed = clip.Rename(UniqueClipName(name, folderPath));
+        var added = new ClipViewModel(renamed) { FolderPath = folderPath };
+        FileMakerClips.Add(added);
+        return added;
+    }
+
+    private sealed class PasteBatchState
+    {
+        public ClipCollisionDecision? StickyDecision { get; set; }
+        public bool Cancelled { get; set; }
     }
 
     private static IReadOnlyList<string> Combine(IReadOnlyList<string> root, IReadOnlyList<string> sub)
diff --git a/tests/SharpFM.Tests/ViewModels/MainWindowViewModelTests.cs b/tests/SharpFM.Tests/ViewModels/MainWindowViewModelTests.cs
index 08a491f..168e2d6 100644
--- a/tests/SharpFM.Tests/ViewModels/MainWindowViewModelTests.cs
+++ b/tests/SharpFM.Tests/ViewModels/MainWindowViewModelTests.cs
@@ -42,13 +42,38 @@ private static MainWindowViewModel CreateVm(
         MockClipboardService? clipboard = null,
         MockFolderService? folderService = null,
         IInputPrompt? prompt = null,
-        ILogger? logger = null)
+        ILogger? logger = null,
+        IClipCollisionPrompt? collisionPrompt = null)
     {
         return new MainWindowViewModel(
             logger ?? NullLoggerFactory.Instance.CreateLogger<MainWindowViewModel>(),
             clipboard ?? new MockClipboardService(),
             folderService ?? new MockFolderService(),
-            prompt);
+            prompt,
+            collisionPrompt);
+    }
+
+    private sealed class FakeCollisionPrompt : IClipCollisionPrompt
+    {
+        private readonly Queue<ClipCollisionDecision> _scripted;
+
+        public FakeCollisionPrompt(params ClipCollisionDecision[] scripted)
+        {
+            _scripted = new Queue<ClipCollisionDecision>(scripted);
+        }
+
+        public int CallCount { get; private set; }
+        public List<string> SeenNames { get; } = new();
+
+        public Task<ClipCollisionDecision> PromptAsync(string clipName, IReadOnlyList<string> folderPath)
+        {
+            CallCount++;
+            SeenNames.Add(clipName);
+            var decision = _scripted.Count > 0
+                ? _scripted.Dequeue()
+                : new ClipCollisionDecision(ClipCollisionChoice.Cancel, ApplyToAll: false);
+            return Task.FromResult(decision);
+        }
     }
 
     private sealed class CapturingLogger : ILogger
@@ -523,7 +548,9 @@ public async Task PasteFileMakerClipData_CollidingName_AppendsNumericSuffix()
         var clipboard = new MockClipboardService();
         clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(
             "<fmxmlsnippet><Script name=\"OrderTotal\"></Script></fmxmlsnippet>");
-        var vm = CreateVm(clipboard);
+        var prompt = new FakeCollisionPrompt(
+            new ClipCollisionDecision(ClipCollisionChoice.KeepBoth, ApplyToAll: false));
+        var vm = CreateVm(clipboard, collisionPrompt: prompt);
         vm.FileMakerClips.Clear();
         vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("OrderTotal", "Mac-XMSC", "<fmxmlsnippet/>")));
 
@@ -532,6 +559,132 @@ public async Task PasteFileMakerClipData_CollidingName_AppendsNumericSuffix()
         Assert.Equal("OrderTotal (2)", vm.SelectedClip!.Clip.Name);
     }
 
+    [Fact]
+    public async Task PasteFileMakerClipData_SameNameSameContent_SkipsDuplicate()
+    {
+        var xml = "<fmxmlsnippet><Script name=\"FizzBuzz\">body</Script></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(xml);
+        var vm = CreateVm(clipboard);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("FizzBuzz", "Mac-XMSC", xml)));
+
+        await vm.PasteFileMakerClipData();
+
+        Assert.Single(vm.FileMakerClips);
+    }
+
+    [Fact]
+    public async Task PasteFileMakerClipData_DifferentNameSameContent_AddsVariant()
+    {
+        var xml = "<fmxmlsnippet><Script name=\"FizzBuzz\">body</Script></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(xml);
+        var vm = CreateVm(clipboard);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("FizzBuzz_v2", "Mac-XMSC", xml)));
+
+        await vm.PasteFileMakerClipData();
+
+        Assert.Equal(2, vm.FileMakerClips.Count);
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "FizzBuzz");
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "FizzBuzz_v2");
+    }
+
+    [Fact]
+    public async Task PasteFileMakerClipData_SameNameDifferentContent_Replace_OverwritesExisting()
+    {
+        var existingXml = "<fmxmlsnippet><Script name=\"FizzBuzz\">old</Script></fmxmlsnippet>";
+        var pasteXml = "<fmxmlsnippet><Script name=\"FizzBuzz\">new</Script></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(pasteXml);
+        var prompt = new FakeCollisionPrompt(
+            new ClipCollisionDecision(ClipCollisionChoice.Replace, ApplyToAll: false));
+        var vm = CreateVm(clipboard, collisionPrompt: prompt);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("FizzBuzz", "Mac-XMSC", existingXml)));
+
+        await vm.PasteFileMakerClipData();
+
+        var only = Assert.Single(vm.FileMakerClips);
+        Assert.Equal("FizzBuzz", only.Clip.Name);
+        Assert.Contains("new", only.Clip.Xml);
+        Assert.Equal(1, prompt.CallCount);
+    }
+
+    [Fact]
+    public async Task PasteFileMakerClipData_SameNameDifferentContent_KeepBoth_AddsWithSuffix()
+    {
+        var existingXml = "<fmxmlsnippet><Script name=\"FizzBuzz\">old</Script></fmxmlsnippet>";
+        var pasteXml = "<fmxmlsnippet><Script name=\"FizzBuzz\">new</Script></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(pasteXml);
+        var prompt = new FakeCollisionPrompt(
+            new ClipCollisionDecision(ClipCollisionChoice.KeepBoth, ApplyToAll: false));
+        var vm = CreateVm(clipboard, collisionPrompt: prompt);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("FizzBuzz", "Mac-XMSC", existingXml)));
+
+        await vm.PasteFileMakerClipData();
+
+        Assert.Equal(2, vm.FileMakerClips.Count);
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "FizzBuzz" && c.Clip.Xml.Contains("old"));
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "FizzBuzz (2)" && c.Clip.Xml.Contains("new"));
+    }
+
+    [Fact]
+    public async Task PasteFileMakerClipData_SameNameDifferentContent_Cancel_AbortsBatch()
+    {
+        var existingXml = "<fmxmlsnippet><Script name=\"FizzBuzz\">old</Script></fmxmlsnippet>";
+        var groupXml =
+            "<fmxmlsnippet type=\"FMObjectList\"><Group id=\"1\" name=\"Drop\">" +
+                "<Script id=\"1\" name=\"FizzBuzz\">first-new</Script>" +
+                "<Script id=\"2\" name=\"NewClip\">second</Script>" +
+            "</Group></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(groupXml);
+        var prompt = new FakeCollisionPrompt(
+            new ClipCollisionDecision(ClipCollisionChoice.Cancel, ApplyToAll: false));
+        var vm = CreateVm(clipboard, collisionPrompt: prompt);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("FizzBuzz", "Mac-XMSC", existingXml))
+            { FolderPath = new[] { "Drop" } });
+
+        await vm.PasteFileMakerClipData();
+
+        Assert.Single(vm.FileMakerClips);
+        Assert.Contains("old", vm.FileMakerClips[0].Clip.Xml);
+        Assert.DoesNotContain(vm.FileMakerClips, c => c.Clip.Name == "NewClip");
+    }
+
+    [Fact]
+    public async Task PasteFileMakerClipData_BatchApplyToAll_DoesNotRepromptForSubsequentCollisions()
+    {
+        var existingA = "<fmxmlsnippet><Script name=\"A\">old-a</Script></fmxmlsnippet>";
+        var existingB = "<fmxmlsnippet><Script name=\"B\">old-b</Script></fmxmlsnippet>";
+        var groupXml =
+            "<fmxmlsnippet type=\"FMObjectList\"><Group id=\"1\" name=\"Drop\">" +
+                "<Script id=\"1\" name=\"A\">new-a</Script>" +
+                "<Script id=\"2\" name=\"B\">new-b</Script>" +
+            "</Group></fmxmlsnippet>";
+        var clipboard = new MockClipboardService();
+        clipboard.ClipboardData["Mac-XMSC"] = BuildClipBytes(groupXml);
+        var prompt = new FakeCollisionPrompt(
+            new ClipCollisionDecision(ClipCollisionChoice.KeepBoth, ApplyToAll: true));
+        var vm = CreateVm(clipboard, collisionPrompt: prompt);
+        vm.FileMakerClips.Clear();
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("A", "Mac-XMSC", existingA))
+            { FolderPath = new[] { "Drop" } });
+        vm.FileMakerClips.Add(new ClipViewModel(Clip.FromXml("B", "Mac-XMSC", existingB))
+            { FolderPath = new[] { "Drop" } });
+
+        await vm.PasteFileMakerClipData();
+
+        Assert.Equal(1, prompt.CallCount);
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "A (2)");
+        Assert.Contains(vm.FileMakerClips, c => c.Clip.Name == "B (2)");
+    }
+
     [Fact]
     public async Task PasteFileMakerClipData_UnknownFormat_PastesAsOpaqueAndWarns()
     {