Opening a workspace that is already opening should not open it a second time

[JoshuaRowePhantom]

Bug Report

If a workspace is already in the process of opening, triggering open again should be a no-op. Currently it allows the workspace to begin opening a second time.

Steps to reproduce

1. Begin opening a workspace
2. While it is still opening, trigger open again

Expected behavior
The second open request is ignored; the workspace opens only once.

Actual behavior
The workspace begins opening a second time.

[JoshuaRowePhantom]

Investigation Findings

Root Cause

File: Phantom.Workspaces/ViewModels/MainWindowViewModel.cs — OpenWorkspaceAsync (~line 973)

The existing "already open" check (lines 985–1008) searches WorkspacePanes for a pane whose .Id matches the workspace's real entity ID. But a workspace that is currently loading only has a loading-workspace:<key> pane — not yet a real pane. So two concurrent calls interleave like this:

1. Call 1 creates the loading pane → await yields (loading entity data)
2. Call 2 finds the same loading pane, navigates to it → await yields
3. Both resume → both search WorkspacePanes for the real entity ID → neither finds it
4. Both fall through to CreateWorkspacePaneAsync and both add a workspace pane

There is no HashSet, SemaphoreSlim, or in-flight tracker anywhere in MainWindowViewModel.

Relationship to bug #22: Bug #22 (double-click from Open button) is the primary trigger — the broken e.Source is Button guard fires OpenWorkspaceAsync twice in rapid succession. Bug #23 is the downstream failure: without an in-flight guard, both calls succeed. Fixing bug #22 reduces the frequency but bug #23 remains independently exploitable.

---

Missing Tests

New tests in Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs:

1. OpenWorkspaceAsync_WhenCalledTwiceConcurrently_AddsWorkspacePaneExactlyOnce — call OpenWorkspaceAsync twice for the same request; await Task.WhenAll(...); assert WorkspacePanes has exactly one pane with the workspace's real entity ID
2. OpenWorkspaceAsync_WhenAlreadyOpening_SecondCallIsNoOp — start first call (don't await); while in-flight, start second call; after both complete, assert only one real workspace pane was added and no duplicate loading pane remains
3. OpenWorkspaceAsync_WhenAlreadyOpening_SelectsExistingLoadingPane — assert the second call navigates to the in-progress loading pane rather than creating a duplicate

---

Recommended Fix

File: Phantom.Workspaces/ViewModels/MainWindowViewModel.cs

Step 1 — add a field (after existing fields, ~line 48):

private readonly HashSet<string> openingWorkspaceKeys = new(StringComparer.Ordinal);

Step 2 — guard OpenWorkspaceAsync — after the loading pane is created/selected but before the first await:

internal async Task OpenWorkspaceAsync(GetEntityRequest workspaceRequest)
{
    var loadingWorkspacePane = this.GetOrCreateLoadingWorkspacePane(workspaceRequest);
    this.SelectedWorkspacePane = loadingWorkspacePane;

    // Guard: if a load is already in flight, navigate to the loading pane but don't start a second load.
    var workspaceKey = GetWorkspaceRequestKey(workspaceRequest);
    if (!this.openingWorkspaceKeys.Add(workspaceKey))
    {
        return;
    }

    try
    {
        // ... existing body unchanged ...
    }
    finally
    {
        this.openingWorkspaceKeys.Remove(workspaceKey);
    }
}

Why this is safe: All calls arrive on the UI thread. HashSet.Add is synchronous — there is no await between the guard check and the Add, so there is no race. The finally block guarantees the key is always removed even if an exception is thrown.

[JoshuaRowePhantom]

Verification Passed ✅

Commit: \734be17\ — Ignore duplicate open of an already-opening workspace (#23)

What was checked

Implementation (Phantom.Workspaces/ViewModels/MainWindowViewModel.cs):

• \GetOrCreateLoadingWorkspacePane\ now returns (WorkspacePaneViewModel Pane, bool AlreadyOpening)\ — if a loading pane for the request already exists, \AlreadyOpening = true.
• \OpenWorkspaceAsync\ immediately returns after navigating to the existing loading pane when \�lreadyOpening\ is \ rue, making any duplicate open request a no-op.
• The approach is race-safe: all UI-thread calls are synchronous up to the first \�wait, so the loading-pane existence check is atomic.

Test (\Phantom.Workspaces.Tests/MainWindowIntegrationTests.cs):

• \OpenWorkspaceAsync_WhenAlreadyOpening_SecondRequestIsNoOp\ — fires two concurrent \OpenWorkspaceAsync\ calls for the same workspace, awaits both, and asserts exactly one real workspace pane was created with no leftover loading pane.

Test run result: Failed: 0, Passed: 1 ✅