fix: 'Existing Folder' no longer overwrites URL-based repo's bare clone

When a repo was first added via 'Add from URL' (creating a managed bare
clone) and then the same repo was added via 'Existing Folder',
AddRepositoryFromLocalAsync was overwriting the existing repo's
BareClonePath to point at the local folder and deleting the managed bare
clone. This made the URL-based repo disappear from the sidebar.

Fix: when an existing repo with the same remote URL is found, keep it
as-is and only register the local folder as an external worktree. The
UI caller (AddLocalFolderAsync) separately creates a 📁 local folder
group, so both entries coexist in the sidebar.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: PureWeen

PolyPilot.Tests/AddExistingRepoTests.cs

@@ -251,6 +251,92 @@ public void AddRepositoryFromLocal_NoBareCloneCreatedInReposDir()
         Assert.Contains("BareClonePath = localPath", methodBody);
     }
 
+    [Fact]
+    public async Task AddRepositoryFromLocal_DoesNotOverwriteExistingUrlBasedRepo()
+    {
+        // Regression: adding a local folder for a repo that was already added via URL
+        // must NOT overwrite the existing repo's BareClonePath. The URL-based repo
+        // (with its managed bare clone) should be preserved; the local folder is only
+        // registered as an external worktree.
+        var tempDir = Path.Combine(Path.GetTempPath(), $"local-overwrite-test-{Guid.NewGuid():N}");
+        var testBaseDir = Path.Combine(Path.GetTempPath(), $"rmtest-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(tempDir);
+        Directory.CreateDirectory(testBaseDir);
+        try
+        {
+            var remoteUrl = "https://github.com/test-owner/overwrite-test.git";
+
+            // Create a local git repo with an origin remote
+            await RunProcess("git", "init", tempDir);
+            await RunProcess("git", "-C", tempDir, "config", "user.email", "test@test.com");
+            await RunProcess("git", "-C", tempDir, "config", "user.name", "Test");
+            await RunProcess("git", "-C", tempDir, "commit", "--allow-empty", "-m", "init");
+            await RunProcess("git", "-C", tempDir, "remote", "add", "origin", remoteUrl);
+
+            var rm = new RepoManager();
+            RepoManager.SetBaseDirForTesting(testBaseDir);
+            try
+            {
+                // Simulate a repo already added via "Add from URL" with a managed bare clone.
+                var id = RepoManager.RepoIdFromUrl(remoteUrl);
+                var barePath = Path.Combine(testBaseDir, "repos", $"{id}.git");
+                Directory.CreateDirectory(barePath);
+                var urlRepo = new RepositoryInfo
+                {
+                    Id = id,
+                    Name = "overwrite-test",
+                    Url = remoteUrl,
+                    BareClonePath = barePath,
+                    AddedAt = DateTime.UtcNow
+                };
+                // Inject the URL-based repo into state
+                var state = new RepositoryState();
+                state.Repositories.Add(urlRepo);
+                var stateFile = Path.Combine(testBaseDir, "repos.json");
+                File.WriteAllText(stateFile, System.Text.Json.JsonSerializer.Serialize(state));
+                rm.Load();
+
+                // Now add the same repo from a local folder
+                var repo = await rm.AddRepositoryFromLocalAsync(tempDir);
+
+                // The returned repo should be the SAME repo (same ID)
+                Assert.Equal(id, repo.Id);
+
+                // CRITICAL: BareClonePath must still point at the managed bare clone,
+                // NOT at the local folder. The local folder should only be registered
+                // as an external worktree.
+                Assert.Equal(Path.GetFullPath(barePath), Path.GetFullPath(repo.BareClonePath));
+
+                // The managed bare clone directory must still exist (not deleted)
+                Assert.True(Directory.Exists(barePath));
+
+                // There should still be exactly ONE repo (not duplicated)
+                Assert.Single(rm.Repositories.Where(r => r.Id == id));
+
+                // The local folder should be registered as an external worktree
+                Assert.Contains(rm.Worktrees, w =>
+                    w.RepoId == id && PathsEqual(w.Path, tempDir));
+            }
+            finally
+            {
+                RepoManager.SetBaseDirForTesting(TestSetup.TestBaseDir);
+            }
+        }
+        finally
+        {
+            ForceDeleteDirectory(tempDir);
+            ForceDeleteDirectory(testBaseDir);
+        }
+    }
+
+    private static bool PathsEqual(string? left, string? right)
+    {
+        if (left == null || right == null) return false;
+        var a = Path.GetFullPath(left).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        var b = Path.GetFullPath(right).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
+    }
+
     private static string ExtractMethodBody(string source, string methodName)
     {
         var idx = source.IndexOf(methodName, StringComparison.Ordinal);

PolyPilot/Services/RepoManager.cs

@@ -607,9 +607,13 @@ await RunGitAsync(barePath, ct, "config", "remote.origin.fetch",
 
     /// <summary>
     /// Add a repository from an existing local path (non-bare). Validates the folder is a
-    /// git repository with an 'origin' remote, then creates a <see cref="RepositoryInfo"/>
+    /// git repository with an 'origin' remote, then either reuses an existing
+    /// <see cref="RepositoryInfo"/> (if one was already added via URL) or creates a new one
     /// whose <see cref="RepositoryInfo.BareClonePath"/> points directly at the user's local
     /// repo — no bare clone is created.
+    /// If a repo with the same remote was already added via "Add from URL", the existing
+    /// repo (and its managed bare clone) is preserved; the local folder is only registered
+    /// as an external worktree.
     /// The local folder is also registered as an external worktree so it appears in the
     /// "📂 Existing" list when creating sessions.
     /// </summary>
@@ -660,23 +664,16 @@ public async Task<RepositoryInfo> AddRepositoryFromLocalAsync(
         var id = RepoIdFromUrl(url);
 
         RepositoryInfo repo;
-        string? oldBareClonePath = null;
         lock (_stateLock)
         {
             var existing = _state.Repositories.FirstOrDefault(r => r.Id == id);
             if (existing != null)
             {
-                // If the old BareClonePath was a managed bare clone, remember it for cleanup.
-                if (!string.IsNullOrWhiteSpace(existing.BareClonePath)
-                    && !PathsEqual(existing.BareClonePath, localPath))
-                {
-                    var fullOld = Path.GetFullPath(existing.BareClonePath);
-                    var managedPrefix = Path.GetFullPath(ReposDir) + Path.DirectorySeparatorChar;
-                    if (fullOld.StartsWith(managedPrefix, StringComparison.OrdinalIgnoreCase))
-                        oldBareClonePath = existing.BareClonePath;
-                }
-                existing.BareClonePath = localPath;
-                BackfillWorktreeClonePaths(existing);
+                // A repo with this remote already exists (e.g., added via "Add from URL").
+                // Keep it as-is — don't overwrite its BareClonePath, which would destroy
+                // the managed bare clone and break any worktrees that depend on it.
+                // The local folder will be registered as an external worktree below,
+                // and the UI caller (AddLocalFolderAsync) will create a 📁 local folder group.
                 repo = existing;
             }
             else
@@ -695,13 +692,6 @@ public async Task<RepositoryInfo> AddRepositoryFromLocalAsync(
         Save();
         OnStateChanged?.Invoke();
 
-        // Clean up orphaned managed bare clone (if any) after state is saved.
-        if (oldBareClonePath != null && Directory.Exists(oldBareClonePath))
-        {
-            try { Directory.Delete(oldBareClonePath, recursive: true); }
-            catch (Exception ex) { Console.WriteLine($"[RepoManager] Failed to clean up old bare clone at '{oldBareClonePath}': {ex.Message}"); }
-        }
-
         // Register the local folder as an external worktree so it also appears in the
         // "📂 Existing" picker when creating repo-based sessions.
         await RegisterExternalWorktreeAsync(repo, localPath, ct);