@@ -321,5 +321,6 @@ apart.
 - Tool discovery uses wildcard path matching (`WildcardFileFinder`) to find executables in common install locations
 - Tool order can be customized via `DiffEngine_ToolOrder` environment variable
 - `DisabledChecker` respects `DiffEngine_Disabled` env var
+- `ViewerClient` remembers a port found unowned for ten minutes (`RecheckUnownedAfter`), and the library's telling sends - settle, retire, move, delete, the first inline or diff send - skip the connect while that stands. A refused loopback connection costs two seconds on Windows (firewall stealth mode drops the reset), and a green run settles once per inline verification, which was six minutes for a class of 188 inline tests. Probes (`IsOwned`), the hosts and `InlineQueueClient` always connect and correct the memory; so does `SettleAppliedInline`, being one send per accept
 - `TrayDisabledChecker` respects `DiffEngine_TrayDisabled` env var, behind `DiffRunner.TrayDisabled`. Separate from `Disabled` because tracking a pending move is separate from launching a tool: every exit of `InnerLaunch`, `Disabled` included, still calls `AddMove`. `PendingFiles.TrayAvailable` is the single gate
 - Tests use TUnit and Verify for snapshot testing
@@ -77,6 +77,7 @@ For the producing side — a test library with a failing inline snapshot:
 
 * `DiffRunner.AddInlineAsync(patch)` queues a patch with whatever owns the port, launching the bundled viewer when nothing does. Returns `Queued`, `Disabled` (build servers, continuous testing and AI CLIs included), or `NoViewerFound` — the caller's cue to stage files and fall back to a text diff.
 * `DiffRunner.SettleInline(sourceFile, line)` drops the pending entry for a call site, for when a previously failing test passes. Unknown entries and an absent owner are no-ops, so call it freely. The settle carries the running framework, so a multi-targeted run only settles its own variant of a conflicted entry. That framework is the running process's, which makes this the test run's verb and only the test run's: a surface applying a patch of its own wants `SettleAppliedInline`, [below](#applying-a-patch-from-another-surface).
+* An absent owner is also remembered. A port found with nothing listening is taken as still unowned for ten minutes, and the sends that only tell the owner something — settle, retire, a move or delete to track, the first attempt to queue a patch — return without connecting while that stands. A refused loopback connection is not free on Windows: the firewall's stealth mode, on by default, drops the reset a closed port would answer with, so each refusal takes two seconds, and a green run settling once per inline verification was spending minutes on them. Anything that has to reach an owner probes for itself before launching a viewer, and that probe, like every listing, always connects and corrects the memory with what it finds.
 * `AddInlineAsync` stamps `patch.Framework` with the consuming project's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. The value is the `$(TargetFramework)` the package's build targets stamp into the project's runtimeconfig, read back rather than asked of the process — in a hosted test run the entry assembly is the runner (testhost, ReSharperTestRunner), whose framework is not the project's — with the running runtime's version as the fallback for consumers without the targets. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
 * Set `patch.OriginalExpression` from `CallerArgumentExpression` where the language supplies one, and `patch.OriginalValue` — the previous expected argument's value — where it does not. One of the two is what stops a patch rewriting the wrong call site when the file has moved since the run. `patch.MemberName` from `CallerMemberName` narrows it further, and is supported everywhere including F#.
 * Setting `DiffEngine_InlineViewer` to `false` reports `NoViewerFound` without probing, which is how a user opts into reviewing in their IDE instead of a window.
@@ -199,7 +200,7 @@ A review surface that is neither the viewer nor the tray — the ReSharper / Rid
 
 `Accept` returns `Accepted` (the entry has gone), `Failed` (still pending and retryable — a locked file, or a conflicted entry that has to be resolved in the viewer), or `Unknown` (nobody owns the queue, or it holds nothing for that call site). It hands back the owner's own message, which is what tells an applied patch from a stale one that was dropped: the wire carries whether the verb was carried out rather than an apply status, so from a client those are the same observation, and only the words separate them.
 
-Listing waits half a second, since an owner that cannot answer one in that time is wedged rather than slow, and a refused connection is immediate either way. Accepting waits fifteen seconds, because the owner applies through `InlineApplier` and that can sit on its cross process mutex for ten.
+Listing waits half a second, since an owner that cannot answer one in that time is wedged rather than slow. A refused connection is immediate on most machines, though not on Windows, where the firewall's stealth mode holds the connect for two seconds; a listing asks every time regardless, because a surface lists precisely to notice an owner arriving, and it is only the test run's fire and forget sends that remember an absent owner for ten minutes instead. Accepting waits fifteen seconds, because the owner applies through `InlineApplier` and that can sit on its cross process mutex for ten.
 
 
 ## Applying a patch from another surface
 
@@ -70,6 +70,7 @@ For the producing side — a test library with a failing inline snapshot:
 
 * `DiffRunner.AddInlineAsync(patch)` queues a patch with whatever owns the port, launching the bundled viewer when nothing does. Returns `Queued`, `Disabled` (build servers, continuous testing and AI CLIs included), or `NoViewerFound` — the caller's cue to stage files and fall back to a text diff.
 * `DiffRunner.SettleInline(sourceFile, line)` drops the pending entry for a call site, for when a previously failing test passes. Unknown entries and an absent owner are no-ops, so call it freely. The settle carries the running framework, so a multi-targeted run only settles its own variant of a conflicted entry. That framework is the running process's, which makes this the test run's verb and only the test run's: a surface applying a patch of its own wants `SettleAppliedInline`, [below](#applying-a-patch-from-another-surface).
+* An absent owner is also remembered. A port found with nothing listening is taken as still unowned for ten minutes, and the sends that only tell the owner something — settle, retire, a move or delete to track, the first attempt to queue a patch — return without connecting while that stands. A refused loopback connection is not free on Windows: the firewall's stealth mode, on by default, drops the reset a closed port would answer with, so each refusal takes two seconds, and a green run settling once per inline verification was spending minutes on them. Anything that has to reach an owner probes for itself before launching a viewer, and that probe, like every listing, always connects and corrects the memory with what it finds.
 * `AddInlineAsync` stamps `patch.Framework` with the consuming project's target framework ("net9.0", "net48") unless the caller already set it, which is what lets the owner tell a re-run from another framework disagreeing. The value is the `$(TargetFramework)` the package's build targets stamp into the project's runtimeconfig, read back rather than asked of the process — in a hosted test run the entry assembly is the runner (testhost, ReSharperTestRunner), whose framework is not the project's — with the running runtime's version as the fallback for consumers without the targets. Callers may also set `patch.TestName`, which the viewer uses to group and label the queue; without it, items are labeled by call site.
 * Set `patch.OriginalExpression` from `CallerArgumentExpression` where the language supplies one, and `patch.OriginalValue` — the previous expected argument's value — where it does not. One of the two is what stops a patch rewriting the wrong call site when the file has moved since the run. `patch.MemberName` from `CallerMemberName` narrows it further, and is supported everywhere including F#.
 * Setting `DiffEngine_InlineViewer` to `false` reports `NoViewerFound` without probing, which is how a user opts into reviewing in their IDE instead of a window.
@@ -192,7 +193,7 @@ A review surface that is neither the viewer nor the tray — the ReSharper / Rid
 
 `Accept` returns `Accepted` (the entry has gone), `Failed` (still pending and retryable — a locked file, or a conflicted entry that has to be resolved in the viewer), or `Unknown` (nobody owns the queue, or it holds nothing for that call site). It hands back the owner's own message, which is what tells an applied patch from a stale one that was dropped: the wire carries whether the verb was carried out rather than an apply status, so from a client those are the same observation, and only the words separate them.
 
-Listing waits half a second, since an owner that cannot answer one in that time is wedged rather than slow, and a refused connection is immediate either way. Accepting waits fifteen seconds, because the owner applies through `InlineApplier` and that can sit on its cross process mutex for ten.
+Listing waits half a second, since an owner that cannot answer one in that time is wedged rather than slow. A refused connection is immediate on most machines, though not on Windows, where the firewall's stealth mode holds the connect for two seconds; a listing asks every time regardless, because a surface lists precisely to notice an owner arriving, and it is only the test run's fire and forget sends that remember an absent owner for ten minutes instead. Accepting waits fifteen seconds, because the owner applies through `InlineApplier` and that can sit on its cross process mutex for ten.
 
 
 ## Applying a patch from another surface
 
@@ -0,0 +1,231 @@
+/// <summary>
+/// The memory of a port nothing was listening on, which is what stops a green run paying for a
+/// refused connection once per inline verification.
+/// <para>
+/// A refused loopback connection is instant on most machines and two seconds on Windows with the
+/// firewall's stealth mode on, which is the default. Each test here meets one refusal at most, on
+/// an ephemeral port of its own, so it costs that once and never talks to the live viewer port.
+/// </para>
+/// </summary>
+[NotInParallel]
+public class ViewerClientUnownedTests
+{
+    static readonly ViewerMessage settle = new(ViewerVerb.Settle, InlineKey.For("Tests.cs", 1));
+
+    // Read before any test can have changed it, so the restore below puts back the real default
+    // rather than a copy of it kept here
+    static readonly TimeSpan recheckUnownedAfter = ViewerClient.RecheckUnownedAfter;
+
+    [Before(Test)]
+    public void Forget() =>
+        ViewerClient.ForgetUnowned();
+
+    [After(Test)]
+    public void Restore()
+    {
+        ViewerClient.RecheckUnownedAfter = recheckUnownedAfter;
+        ViewerClient.ForgetUnowned();
+    }
+
+    /// <summary>
+    /// The first refusal is remembered, so the next telling send returns without connecting - and
+    /// keeps returning that way once somebody is there, until something asks.
+    /// </summary>
+    [Test]
+    public async Task ARefusalIsRemembered()
+    {
+        var port = FreePort();
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsFalse();
+
+        using var owner = new Owner(port);
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsFalse();
+        await Assert.That(owner.Heard).IsEmpty();
+    }
+
+    /// <summary>
+    /// An ask always connects, and having found the owner, corrects the memory for the sends
+    /// after it.
+    /// </summary>
+    [Test]
+    public async Task AnAskCorrectsTheMemory()
+    {
+        var port = FreePort();
+        ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true);
+        using var owner = new Owner(port);
+
+        await Assert.That(ViewerClient.TrySend(settle, out _, port)).IsTrue();
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsTrue();
+        await Assert.That(owner.Heard.Count).IsEqualTo(2);
+    }
+
+    /// <summary>
+    /// The probe is the ask that matters most. The launch gate runs it once a viewer is started,
+    /// and the sends queued behind the gate have to reach the viewer it found.
+    /// </summary>
+    [Test]
+    public async Task TheProbeCorrectsTheMemory()
+    {
+        var port = FreePort();
+        ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true);
+        using var owner = new Owner(port);
+
+        await Assert.That(ViewerClient.IsOwned(port)).IsTrue();
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsTrue();
+        await Assert.That(owner.Heard.Count).IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// A probe finding nobody is remembered too. The gate probes once per launch, and a viewer
+    /// that never binds would otherwise leave every send in the run paying for the refusal.
+    /// </summary>
+    [Test]
+    public async Task AProbeFindingNobodyIsRemembered()
+    {
+        var port = FreePort();
+        await Assert.That(ViewerClient.IsOwned(port)).IsFalse();
+
+        using var owner = new Owner(port);
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsFalse();
+        await Assert.That(owner.Heard).IsEmpty();
+    }
+
+    /// <summary>
+    /// A tray started mid run is found once the memory has expired, without anything asking.
+    /// </summary>
+    [Test]
+    public async Task TheMemoryExpires()
+    {
+        ViewerClient.RecheckUnownedAfter = TimeSpan.Zero;
+        var port = FreePort();
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsFalse();
+
+        using var owner = new Owner(port);
+        await Assert.That(ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true)).IsTrue();
+        await Assert.That(owner.Heard.Count).IsEqualTo(1);
+    }
+
+    /// <summary>
+    /// Per port, or a test suite's dead ephemeral port would silence the sends to its live one.
+    /// </summary>
+    [Test]
+    public async Task PortsAreRememberedApart()
+    {
+        var dead = FreePort();
+        using var owner = new Owner();
+        await Assert.That(ViewerClient.TrySend(settle, out _, dead, skipIfUnowned: true)).IsFalse();
+
+        await Assert.That(ViewerClient.TrySend(settle, out _, owner.Port, skipIfUnowned: true)).IsTrue();
+        await Assert.That(owner.Heard.Count).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task TheAsyncSendRemembersToo()
+    {
+        var port = FreePort();
+        await Assert.That(await ViewerClient.SendAsync(settle, Cancel.None, port, skipIfUnowned: true))
+            .IsEqualTo(SendOutcome.NoOwner);
+
+        using var owner = new Owner(port);
+        await Assert.That(await ViewerClient.SendAsync(settle, Cancel.None, port, skipIfUnowned: true))
+            .IsEqualTo(SendOutcome.NoOwner);
+        await Assert.That(owner.Heard).IsEmpty();
+
+        await Assert.That(ViewerClient.IsOwned(port)).IsTrue();
+        await Assert.That(await ViewerClient.SendAsync(settle, Cancel.None, port, skipIfUnowned: true))
+            .IsEqualTo(SendOutcome.Accepted);
+    }
+
+    /// <summary>
+    /// A caller that does not say is asking, and an ask is never answered from memory. This is
+    /// what keeps the hosts and the IDE plugin, which share this client, noticing an owner arrive.
+    /// </summary>
+    [Test]
+    public async Task AskingIsTheDefault()
+    {
+        var port = FreePort();
+        ViewerClient.TrySend(settle, out _, port, skipIfUnowned: true);
+        using var owner = new Owner(port);
+
+        await Assert.That(await ViewerClient.SendAsync(settle, Cancel.None, port)).IsEqualTo(SendOutcome.Accepted);
+        await Assert.That(ViewerClient.TrySend(settle, out _, port)).IsTrue();
+        await Assert.That(owner.Heard.Count).IsEqualTo(2);
+    }
+
+    /// <summary>
+    /// A port that is free right now, found by binding and releasing it.
+    /// </summary>
+    static int FreePort()
+    {
+        if (!ViewerServer.TryBind(0, out var bound))
+        {
+            throw new("Could not bind an ephemeral port.");
+        }
+
+        var port = bound.Port;
+        bound.Dispose();
+        return port;
+    }
+
+    /// <summary>
+    /// A queue owner on a port of the test's choosing, answering every verb and recording it.
+    /// Zero binds an ephemeral port, for a test that only needs somebody to be there.
+    /// </summary>
+    sealed class Owner : IDisposable
+    {
+        readonly ViewerServer server;
+        readonly CancelSource cancel = new();
+        readonly Task listening;
+        readonly Lock gate = new();
+        readonly List<ViewerVerb> heard = [];
+
+        public Owner(int port = 0)
+        {
+            if (!ViewerServer.TryBind(port, out var bound))
+            {
+                throw new($"Could not bind port {port}.");
+            }
+
+            server = bound;
+            listening = server.Listen(
+                _ =>
+                {
+                    lock (gate)
+                    {
+                        heard.Add(_.Verb);
+                    }
+
+                    return ViewerResponse.Success();
+                },
+                cancel.Token);
+        }
+
+        public int Port => server.Port;
+
+        public IReadOnlyList<ViewerVerb> Heard
+        {
+            get
+            {
+                lock (gate)
+                {
+                    return heard.ToList();
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            cancel.Cancel();
+            server.Dispose();
+            try
+            {
+                listening.Wait(TimeSpan.FromSeconds(2));
+            }
+            catch (AggregateException)
+            {
+                // Cancellation unwinding through the listener; nothing to report
+            }
+
+            cancel.Dispose();
+        }
+    }
+}