From e6e2193856fbec32d2e01287017d7c24876fa483 Mon Sep 17 00:00:00 2001
From: vitek-karas <10670590+vitek-karas@users.noreply.github.com>
Date: Wed, 4 Mar 2026 20:19:49 +0100
Subject: [PATCH] Add configurable repo storage root and reclone workflow

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 PolyPilot.Tests/ConnectionSettingsTests.cs |  18 ++-
 PolyPilot.Tests/RepoManagerStorageTests.cs | 112 +++++++++++++++++
 PolyPilot/Components/Pages/Settings.razor  | 111 ++++++++++++++++-
 PolyPilot/Models/ConnectionSettings.cs     |   9 ++
 PolyPilot/Models/RepositoryInfo.cs         |   2 +
 PolyPilot/Services/RepoManager.cs          | 137 +++++++++++++++++----
 6 files changed, 366 insertions(+), 23 deletions(-)
 create mode 100644 PolyPilot.Tests/RepoManagerStorageTests.cs

diff --git a/PolyPilot.Tests/ConnectionSettingsTests.cs b/PolyPilot.Tests/ConnectionSettingsTests.cs
index 0077eed025..32db20b9d4 100644
--- a/PolyPilot.Tests/ConnectionSettingsTests.cs
+++ b/PolyPilot.Tests/ConnectionSettingsTests.cs
@@ -142,6 +142,7 @@ public void DefaultValues_NewFields_AreCorrect()
         Assert.Null(settings.ServerPassword);
         Assert.False(settings.DirectSharingEnabled);
         Assert.Equal(CliSourceMode.BuiltIn, settings.CliSource);
+        Assert.Null(settings.RepositoryStorageRoot);
     }
 
     [Fact]
@@ -154,7 +155,8 @@ public void Save_Load_RoundTrip_WithNewFields()
             Port = 4321,
             ServerPassword = "mypass",
             DirectSharingEnabled = true,
-            CliSource = CliSourceMode.System
+            CliSource = CliSourceMode.System,
+            RepositoryStorageRoot = "D:\\DevDrive\\PolyPilot"
         };
 
         var json = JsonSerializer.Serialize(original);
@@ -164,6 +166,7 @@ public void Save_Load_RoundTrip_WithNewFields()
         Assert.Equal("mypass", loaded!.ServerPassword);
         Assert.True(loaded.DirectSharingEnabled);
         Assert.Equal(CliSourceMode.System, loaded.CliSource);
+        Assert.Equal("D:\\DevDrive\\PolyPilot", loaded.RepositoryStorageRoot);
     }
 
     [Fact]
@@ -178,6 +181,19 @@ public void BackwardCompatibility_OldJsonWithoutNewFields()
         Assert.Null(loaded.ServerPassword);
         Assert.False(loaded.DirectSharingEnabled);
         Assert.Equal(CliSourceMode.BuiltIn, loaded.CliSource);
+        Assert.Null(loaded.RepositoryStorageRoot);
+    }
+
+    [Fact]
+    public void NormalizeRepositoryStorageRoot_Whitespace_ReturnsNull()
+    {
+        Assert.Null(ConnectionSettings.NormalizeRepositoryStorageRoot("   "));
+    }
+
+    [Fact]
+    public void NormalizeRepositoryStorageRoot_TrimmedPath_ReturnsTrimmed()
+    {
+        Assert.Equal("C:\\Dev", ConnectionSettings.NormalizeRepositoryStorageRoot("  C:\\Dev  "));
     }
 
     [Fact]
diff --git a/PolyPilot.Tests/RepoManagerStorageTests.cs b/PolyPilot.Tests/RepoManagerStorageTests.cs
new file mode 100644
index 0000000000..94236668ba
--- /dev/null
+++ b/PolyPilot.Tests/RepoManagerStorageTests.cs
@@ -0,0 +1,112 @@
+using System.Reflection;
+using System.Text.Json;
+using PolyPilot.Models;
+using PolyPilot.Services;
+
+namespace PolyPilot.Tests;
+
+public class RepoManagerStorageTests
+{
+    private static RepoManager CreateRepoManagerWithState(RepositoryState state)
+    {
+        var rm = new RepoManager();
+        var stateField = typeof(RepoManager).GetField("_state", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        var loadedField = typeof(RepoManager).GetField("_loaded", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        stateField.SetValue(rm, state);
+        loadedField.SetValue(rm, true);
+        return rm;
+    }
+
+    private static void InvokeBackfillWorktreeClonePaths(RepoManager rm, RepositoryInfo repo)
+    {
+        var method = typeof(RepoManager).GetMethod("BackfillWorktreeClonePaths", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        method.Invoke(rm, new object[] { repo });
+    }
+
+    [Fact]
+    public void BackfillWorktreeClonePaths_FillsMissingPaths()
+    {
+        var repo = new RepositoryInfo { Id = "owner-repo", BareClonePath = "/old/repos/owner-repo.git" };
+        var state = new RepositoryState
+        {
+            Repositories = new List<RepositoryInfo> { repo },
+            Worktrees = new List<WorktreeInfo>
+            {
+                new() { Id = "wt1", RepoId = "owner-repo", Path = "/old/worktrees/owner-repo-a1b2c3d4" },
+                new() { Id = "wt2", RepoId = "other-repo", Path = "/old/worktrees/other-repo-e5f6g7h8" }
+            }
+        };
+        var rm = CreateRepoManagerWithState(state);
+
+        InvokeBackfillWorktreeClonePaths(rm, repo);
+
+        Assert.Equal("/old/repos/owner-repo.git", state.Worktrees[0].BareClonePath);
+        Assert.Null(state.Worktrees[1].BareClonePath);
+    }
+
+    [Fact]
+    public void BackfillWorktreeClonePaths_DoesNotOverwriteExistingPath()
+    {
+        var repo = new RepositoryInfo { Id = "owner-repo", BareClonePath = "/new/repos/owner-repo.git" };
+        var state = new RepositoryState
+        {
+            Repositories = new List<RepositoryInfo> { repo },
+            Worktrees = new List<WorktreeInfo>
+            {
+                new()
+                {
+                    Id = "wt1",
+                    RepoId = "owner-repo",
+                    Path = "/old/worktrees/owner-repo-a1b2c3d4",
+                    BareClonePath = "/old/repos/owner-repo.git"
+                }
+            }
+        };
+        var rm = CreateRepoManagerWithState(state);
+
+        InvokeBackfillWorktreeClonePaths(rm, repo);
+
+        Assert.Equal("/old/repos/owner-repo.git", state.Worktrees[0].BareClonePath);
+    }
+
+    [Fact]
+    public void RepositoryState_WorktreeBareClonePath_RoundTripsJson()
+    {
+        var original = new RepositoryState
+        {
+            Repositories = new List<RepositoryInfo>
+            {
+                new() { Id = "owner-repo", BareClonePath = "/repos/owner-repo.git", Url = "https://github.com/owner/repo" }
+            },
+            Worktrees = new List<WorktreeInfo>
+            {
+                new() { Id = "wt1", RepoId = "owner-repo", Path = "/worktrees/owner-repo-1234", BareClonePath = "/repos/owner-repo.git" }
+            }
+        };
+
+        var json = JsonSerializer.Serialize(original);
+        var roundTrip = JsonSerializer.Deserialize<RepositoryState>(json);
+
+        Assert.NotNull(roundTrip);
+        Assert.Single(roundTrip!.Worktrees);
+        Assert.Equal("/repos/owner-repo.git", roundTrip.Worktrees[0].BareClonePath);
+    }
+
+    [Fact]
+    public async Task RecloneAllRepositoriesToCurrentRootAsync_NoRepos_Completes()
+    {
+        var rm = CreateRepoManagerWithState(new RepositoryState());
+        await rm.RecloneAllRepositoriesToCurrentRootAsync();
+        Assert.Empty(rm.Repositories);
+    }
+
+    [Fact]
+    public void PathsEqual_IgnoresTrailingSeparator()
+    {
+        var method = typeof(RepoManager).GetMethod("PathsEqual", BindingFlags.NonPublic | BindingFlags.Static)!;
+        var root = Path.Combine(Path.GetTempPath(), "polypilot-repo-root");
+        var withTrailing = root + Path.DirectorySeparatorChar;
+        var equal = (bool)method.Invoke(null, new object[] { withTrailing, root })!;
+        Assert.True(equal);
+    }
+}
diff --git a/PolyPilot/Components/Pages/Settings.razor b/PolyPilot/Components/Pages/Settings.razor
index e0f5416cc4..cb0594c3c4 100644
--- a/PolyPilot/Components/Pages/Settings.razor
+++ b/PolyPilot/Components/Pages/Settings.razor
@@ -9,6 +9,7 @@
 @inject QrScannerService QrScanner
 @inject GitAutoUpdateService GitAutoUpdate
 @inject FiestaService FiestaService
+@inject RepoManager RepoManager
 @inject NavigationManager Nav
 @inject IJSRuntime JS
 @inject IServiceProvider ServiceProvider
@@ -354,6 +355,40 @@
         </div>
     }
 
+    @if (PlatformHelper.IsDesktop)
+    {
+        <div class="settings-section @(SectionVisible("repository repo clone worktree storage root directory dev drive") ? "" : "search-hidden")">
+            <h3>Repository Storage</h3>
+            <p class="mode-hint">Root folder used for managed bare clones and worktrees.</p>
+            <div class="url-input">
+                <label>Storage Root:</label>
+                <input type="text" @bind="settings.RepositoryStorageRoot" placeholder="@RepoManager.GetEffectiveStorageRoot()" class="form-input wide" />
+            </div>
+            <div class="server-buttons">
+                <button class="start-btn" @onclick="BrowseRepositoryStorageRoot">Browse…</button>
+                <button class="stop-btn" @onclick="UseDefaultRepositoryStorageRoot">Use Default</button>
+            </div>
+            @if (RepositoryStorageRootChanged)
+            {
+                <div class="mode-changed-hint">
+                    <span>Existing sessions/worktrees stay where they are. New worktrees use the new root after save.</span>
+                </div>
+                @if (RepoManager.Repositories.Count > 0)
+                {
+                    <div class="mode-changed-hint">
+                        <button class="reconnect-inline-btn" @onclick="RecloneAllRegisteredRepos" disabled="@recloneBusy">
+                            @(recloneBusy ? "Re-cloning..." : "Re-clone all registered repos in new root")
+                        </button>
+                        @if (!string.IsNullOrWhiteSpace(recloneProgress))
+                        {
+                            <span>@recloneProgress</span>
+                        }
+                    </div>
+                }
+            }
+        </div>
+    }
+
     <div class="settings-section">
         <div class="save-row">
             <button class="save-btn" @onclick="SaveAndApply">
@@ -544,6 +579,8 @@
     private bool tunnelLoggedIn;
     private bool tunnelBusy;
     private bool showToken;
+    private bool recloneBusy;
+    private string? recloneProgress;
     private string? qrCodeDataUri;
     private string? directQrCodeDataUri;
     private List<string> localIps = new();
@@ -554,6 +591,7 @@
     private CliSourceMode _initialCliSource;
     private ConnectionMode _initialMode;
     private bool cliSourceChanged;
+    private string _initialRepositoryStorageRoot = "";
     private int fontSize = 20;
     private string fiestaLinkName = "";
     private string fiestaLinkUrl = "";
@@ -589,7 +627,7 @@
         // Also check all section keywords within the group
         return groupKeyword switch
         {
-            "connection" => SectionVisible("transport mode embedded persistent remote server port start stop pid devtunnel share tunnel mobile qr url token connect save reconnect"),
+            "connection" => SectionVisible("transport mode embedded persistent remote server port start stop pid devtunnel share tunnel mobile qr url token connect save reconnect repository repo clone worktree storage root directory"),
             "ui" => SectionVisible("chat message layout default reversed both left theme font size text zoom"),
             "developer" => SectionVisible("auto update main git watch relaunch rebuild"),
             _ => true
@@ -617,8 +655,10 @@
     protected override void OnInitialized()
     {
         settings = ConnectionSettings.Load();
+        settings.RepositoryStorageRoot = ConnectionSettings.NormalizeRepositoryStorageRoot(settings.RepositoryStorageRoot);
         _initialCliSource = settings.CliSource;
         _initialMode = settings.Mode;
+        _initialRepositoryStorageRoot = NormalizePathForCompare(settings.RepositoryStorageRoot);
         DevTunnelService.OnStateChanged += OnTunnelStateChanged;
         GitAutoUpdate.OnStateChanged += OnAutoUpdateStateChanged;
         FiestaService.OnStateChanged += OnFiestaStateChanged;
@@ -766,6 +806,67 @@
         settings.Save();
     }
 
+    private static string NormalizePathForCompare(string? path)
+    {
+        var normalized = ConnectionSettings.NormalizeRepositoryStorageRoot(path);
+        if (string.IsNullOrWhiteSpace(normalized))
+            return "";
+        return normalized.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+    }
+
+    private bool RepositoryStorageRootChanged =>
+        !string.Equals(NormalizePathForCompare(settings.RepositoryStorageRoot), _initialRepositoryStorageRoot, StringComparison.OrdinalIgnoreCase);
+
+    private static bool IsStorageRootValid(string? path) =>
+        string.IsNullOrWhiteSpace(path) || Path.IsPathRooted(path.Trim());
+
+    private async Task BrowseRepositoryStorageRoot()
+    {
+        var dir = await FolderPickerService.PickFolderAsync();
+        if (!string.IsNullOrWhiteSpace(dir))
+            settings.RepositoryStorageRoot = dir;
+    }
+
+    private void UseDefaultRepositoryStorageRoot()
+    {
+        settings.RepositoryStorageRoot = null;
+    }
+
+    private async Task RecloneAllRegisteredRepos()
+    {
+        settings.RepositoryStorageRoot = ConnectionSettings.NormalizeRepositoryStorageRoot(settings.RepositoryStorageRoot);
+        if (!IsStorageRootValid(settings.RepositoryStorageRoot))
+        {
+            ShowStatus("Repository storage root must be an absolute path", "error", 5000);
+            return;
+        }
+
+        settings.Save();
+        recloneBusy = true;
+        recloneProgress = null;
+        StateHasChanged();
+
+        try
+        {
+            await RepoManager.RecloneAllRepositoriesToCurrentRootAsync(progress =>
+            {
+                recloneProgress = progress;
+                _ = InvokeAsync(StateHasChanged);
+            });
+            _initialRepositoryStorageRoot = NormalizePathForCompare(settings.RepositoryStorageRoot);
+            ShowStatus("Repositories re-cloned to new root", "success", 3500);
+        }
+        catch (Exception ex)
+        {
+            ShowStatus($"Re-clone failed: {Models.ErrorMessageHelper.Humanize(ex)}", "error", 8000);
+        }
+        finally
+        {
+            recloneBusy = false;
+            StateHasChanged();
+        }
+    }
+
     private static string ShortenPath(string path)
     {
         // Show just the last 2-3 segments for readability
@@ -1061,6 +1162,13 @@
 
     private async Task SaveAndApply()
     {
+        settings.RepositoryStorageRoot = ConnectionSettings.NormalizeRepositoryStorageRoot(settings.RepositoryStorageRoot);
+        if (!IsStorageRootValid(settings.RepositoryStorageRoot))
+        {
+            ShowStatus("Repository storage root must be an absolute path", "error", 5000);
+            return;
+        }
+
         if (settings.Mode == ConnectionMode.Persistent && !serverAlive)
         {
             ShowStatus("Start the persistent server first", "error", 5000);
@@ -1081,6 +1189,7 @@
             await CopilotService.ReconnectAsync(settings);
             _initialMode = settings.Mode;
             _initialCliSource = settings.CliSource;
+            _initialRepositoryStorageRoot = NormalizePathForCompare(settings.RepositoryStorageRoot);
             cliSourceChanged = false;
             ShowStatus("Connected!", "success");
             Nav.NavigateTo("/");
diff --git a/PolyPilot/Models/ConnectionSettings.cs b/PolyPilot/Models/ConnectionSettings.cs
index bb8b46aa8f..50eb444dc1 100644
--- a/PolyPilot/Models/ConnectionSettings.cs
+++ b/PolyPilot/Models/ConnectionSettings.cs
@@ -56,6 +56,7 @@ public class ConnectionSettings
     public UiTheme Theme { get; set; } = UiTheme.System;
     public bool AutoUpdateFromMain { get; set; } = false;
     public CliSourceMode CliSource { get; set; } = CliSourceMode.BuiltIn;
+    public string? RepositoryStorageRoot { get; set; }
     public List<string> DisabledMcpServers { get; set; } = new();
     public List<string> DisabledPlugins { get; set; } = new();
     public bool EnableSessionNotifications { get; set; } = false;
@@ -111,10 +112,18 @@ public static ConnectionSettings Load()
         // Ensure loaded mode is valid for this platform
         if (!PlatformHelper.AvailableModes.Contains(settings.Mode))
             settings.Mode = PlatformHelper.DefaultMode;
+        settings.RepositoryStorageRoot = NormalizeRepositoryStorageRoot(settings.RepositoryStorageRoot);
 
         return settings;
     }
 
+    public static string? NormalizeRepositoryStorageRoot(string? path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+            return null;
+        return path.Trim();
+    }
+
     private static ConnectionSettings DefaultSettings()
     {
 #if ANDROID
diff --git a/PolyPilot/Models/RepositoryInfo.cs b/PolyPilot/Models/RepositoryInfo.cs
index 6d765c29e5..53d8cbdb0a 100644
--- a/PolyPilot/Models/RepositoryInfo.cs
+++ b/PolyPilot/Models/RepositoryInfo.cs
@@ -24,6 +24,8 @@ public class WorktreeInfo
     public string RepoId { get; set; } = "";
     public string Branch { get; set; } = "";
     public string Path { get; set; } = "";
+    /// <summary>Path to the bare clone backing this worktree.</summary>
+    public string? BareClonePath { get; set; }
     /// <summary>Session name using this worktree as CWD, if any.</summary>
     public string? SessionName { get; set; }
     /// <summary>GitHub PR number if this worktree was created from a PR.</summary>
diff --git a/PolyPilot/Services/RepoManager.cs b/PolyPilot/Services/RepoManager.cs
index d589b3a74a..76af80ee73 100644
--- a/PolyPilot/Services/RepoManager.cs
+++ b/PolyPilot/Services/RepoManager.cs
@@ -6,16 +6,15 @@ namespace PolyPilot.Services;
 
 /// <summary>
 /// Manages bare git clones and worktrees for repository-centric sessions.
-/// Repos live at ~/.polypilot/repos/<id>.git, worktrees at ~/.polypilot/worktrees/<id>/.
+/// Clone and worktree roots are configurable via ConnectionSettings.RepositoryStorageRoot.
+/// Metadata state remains in ~/.polypilot/repos.json.
 /// </summary>
 public class RepoManager
 {
-    private static string? _reposDir;
-    private static string ReposDir => _reposDir ??= GetReposDir();
-    private static string? _worktreesDir;
-    private static string WorktreesDir => _worktreesDir ??= GetWorktreesDir();
     private static string? _stateFile;
     private static string StateFile => _stateFile ??= GetStateFile();
+    private string ReposDir => Path.Combine(GetStorageRootDir(), "repos");
+    private string WorktreesDir => Path.Combine(GetStorageRootDir(), "worktrees");
 
     private RepositoryState _state = new();
     private bool _loaded;
@@ -44,10 +43,21 @@ private static string GetBaseDir()
         }
     }
 
-    private static string GetReposDir() => Path.Combine(GetBaseDir(), "repos");
-    private static string GetWorktreesDir() => Path.Combine(GetBaseDir(), "worktrees");
     private static string GetStateFile() => Path.Combine(GetBaseDir(), "repos.json");
 
+    private static string GetStorageRootDir()
+    {
+        try
+        {
+            var settings = ConnectionSettings.Load();
+            var configuredRoot = ConnectionSettings.NormalizeRepositoryStorageRoot(settings.RepositoryStorageRoot);
+            if (!string.IsNullOrEmpty(configuredRoot) && Path.IsPathRooted(configuredRoot))
+                return configuredRoot;
+        }
+        catch { }
+        return GetBaseDir();
+    }
+
     public void Load()
     {
         _loaded = true;
@@ -58,6 +68,19 @@ public void Load()
                 var json = File.ReadAllText(StateFile);
                 _state = JsonSerializer.Deserialize<RepositoryState>(json) ?? new RepositoryState();
             }
+            var repoPathsById = _state.Repositories
+                .Where(r => !string.IsNullOrWhiteSpace(r.BareClonePath))
+                .ToDictionary(r => r.Id, r => r.BareClonePath, StringComparer.OrdinalIgnoreCase);
+            var changed = false;
+            foreach (var wt in _state.Worktrees.Where(w => string.IsNullOrWhiteSpace(w.BareClonePath)))
+            {
+                if (repoPathsById.TryGetValue(wt.RepoId, out var bareClonePath))
+                {
+                    wt.BareClonePath = bareClonePath;
+                    changed = true;
+                }
+            }
+            if (changed) Save();
         }
         catch (Exception ex)
         {
@@ -113,6 +136,71 @@ public static string NormalizeRepoUrl(string input)
         return input;
     }
 
+    public string GetEffectiveStorageRoot() => GetStorageRootDir();
+
+    private string GetDesiredBareClonePath(string repoId) => Path.Combine(ReposDir, $"{repoId}.git");
+
+    private static bool PathsEqual(string left, string right)
+    {
+        var normalizedLeft = Path.GetFullPath(left).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        var normalizedRight = Path.GetFullPath(right).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        return string.Equals(normalizedLeft, normalizedRight, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private void BackfillWorktreeClonePaths(RepositoryInfo repo)
+    {
+        if (string.IsNullOrWhiteSpace(repo.BareClonePath))
+            return;
+        foreach (var wt in _state.Worktrees.Where(w => w.RepoId == repo.Id && string.IsNullOrWhiteSpace(w.BareClonePath)))
+            wt.BareClonePath = repo.BareClonePath;
+    }
+
+    private async Task EnsureRepoCloneInCurrentRootAsync(RepositoryInfo repo, Action<string>? onProgress, CancellationToken ct)
+    {
+        var targetBarePath = GetDesiredBareClonePath(repo.Id);
+        if (PathsEqual(repo.BareClonePath, targetBarePath) && Directory.Exists(targetBarePath))
+            return;
+
+        BackfillWorktreeClonePaths(repo);
+        Directory.CreateDirectory(ReposDir);
+
+        if (Directory.Exists(targetBarePath))
+        {
+            onProgress?.Invoke($"Fetching {repo.Id}…");
+            try { await RunGitAsync(targetBarePath, ct, "config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"); } catch { }
+            await RunGitWithProgressAsync(targetBarePath, onProgress, ct, "fetch", "--progress", "origin");
+        }
+        else
+        {
+            onProgress?.Invoke($"Cloning {repo.Url}…");
+            await RunGitWithProgressAsync(null, onProgress, ct, "clone", "--bare", "--progress", repo.Url, targetBarePath);
+            await RunGitAsync(targetBarePath, ct, "config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*");
+            onProgress?.Invoke($"Fetching refs…");
+            await RunGitWithProgressAsync(targetBarePath, onProgress, ct, "fetch", "--progress", "origin");
+        }
+
+        if (OperatingSystem.IsWindows())
+        {
+            try { await RunGitAsync(targetBarePath, ct, "config", "core.longpaths", "true"); } catch { }
+        }
+
+        repo.BareClonePath = targetBarePath;
+        Save();
+        OnStateChanged?.Invoke();
+    }
+
+    public async Task RecloneAllRepositoriesToCurrentRootAsync(Action<string>? onProgress = null, CancellationToken ct = default)
+    {
+        EnsureLoaded();
+        var total = _state.Repositories.Count;
+        for (var index = 0; index < total; index++)
+        {
+            var repo = _state.Repositories[index];
+            onProgress?.Invoke($"[{index + 1}/{total}] {repo.Name}");
+            await EnsureRepoCloneInCurrentRootAsync(repo, onProgress, ct);
+        }
+    }
+
     /// <summary>
     /// Clone a repository as bare. Returns the RepositoryInfo.
     /// If already tracked, returns existing entry.
@@ -128,20 +216,12 @@ public async Task<RepositoryInfo> AddRepositoryAsync(string url, Action<string>?
         var existing = _state.Repositories.FirstOrDefault(r => r.Id == id);
         if (existing != null)
         {
-            onProgress?.Invoke($"Fetching {id}…");
-            try { await RunGitAsync(existing.BareClonePath, ct, "config", "remote.origin.fetch",
-                "+refs/heads/*:refs/remotes/origin/*"); } catch { }
-            await RunGitWithProgressAsync(existing.BareClonePath, onProgress, ct, "fetch", "--progress", "origin");
-            // Ensure long paths are enabled for existing repos on Windows
-            if (OperatingSystem.IsWindows())
-            {
-                try { await RunGitAsync(existing.BareClonePath, ct, "config", "core.longpaths", "true"); } catch { }
-            }
+            await EnsureRepoCloneInCurrentRootAsync(existing, onProgress, ct);
             return existing;
         }
 
         Directory.CreateDirectory(ReposDir);
-        var barePath = Path.Combine(ReposDir, $"{id}.git");
+        var barePath = GetDesiredBareClonePath(id);
 
         if (Directory.Exists(barePath))
         {
@@ -205,6 +285,7 @@ public async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, string branch
         EnsureLoaded();
         var repo = _state.Repositories.FirstOrDefault(r => r.Id == repoId)
             ?? throw new InvalidOperationException($"Repository '{repoId}' not found.");
+        await EnsureRepoCloneInCurrentRootAsync(repo, null, ct);
 
         // Fetch latest from origin (prune to clean up deleted remote branches)
         await RunGitAsync(repo.BareClonePath, ct, "fetch", "--prune", "origin");
@@ -225,6 +306,7 @@ public async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, string branch
             RepoId = repoId,
             Branch = branchName,
             Path = worktreePath,
+            BareClonePath = repo.BareClonePath,
             CreatedAt = DateTime.UtcNow
         };
         _state.Worktrees.Add(wt);
@@ -242,6 +324,7 @@ public async Task<WorktreeInfo> CreateWorktreeFromPrAsync(string repoId, int prN
         EnsureLoaded();
         var repo = _state.Repositories.FirstOrDefault(r => r.Id == repoId)
             ?? throw new InvalidOperationException($"Repository '{repoId}' not found.");
+        await EnsureRepoCloneInCurrentRootAsync(repo, null, ct);
 
         // Fetch the PR ref
         await RunGitAsync(repo.BareClonePath, ct, "fetch", "origin", $"pull/{prNumber}/head:pr-{prNumber}");
@@ -259,6 +342,7 @@ public async Task<WorktreeInfo> CreateWorktreeFromPrAsync(string repoId, int prN
             RepoId = repoId,
             Branch = branchName,
             Path = worktreePath,
+            BareClonePath = repo.BareClonePath,
             PrNumber = prNumber,
             CreatedAt = DateTime.UtcNow
         };
@@ -277,21 +361,30 @@ public async Task RemoveWorktreeAsync(string worktreeId, CancellationToken ct =
         var wt = _state.Worktrees.FirstOrDefault(w => w.Id == worktreeId);
         if (wt == null) return;
 
-        var repo = _state.Repositories.FirstOrDefault(r => r.Id == wt.RepoId);
-        if (repo != null)
+        var bareClonePath = wt.BareClonePath;
+        if (string.IsNullOrWhiteSpace(bareClonePath))
+        {
+            var repo = _state.Repositories.FirstOrDefault(r => r.Id == wt.RepoId);
+            bareClonePath = repo?.BareClonePath;
+        }
+        if (!string.IsNullOrWhiteSpace(bareClonePath))
         {
             try
             {
-                await RunGitAsync(repo.BareClonePath, ct, "worktree", "remove", wt.Path, "--force");
+                await RunGitAsync(bareClonePath, ct, "worktree", "remove", wt.Path, "--force");
             }
             catch
             {
                 // Force cleanup if git worktree remove fails
                 if (Directory.Exists(wt.Path))
                     Directory.Delete(wt.Path, recursive: true);
-                await RunGitAsync(repo.BareClonePath, ct, "worktree", "prune");
+                await RunGitAsync(bareClonePath, ct, "worktree", "prune");
             }
         }
+        else if (Directory.Exists(wt.Path))
+        {
+            Directory.Delete(wt.Path, recursive: true);
+        }
 
         _state.Worktrees.RemoveAll(w => w.Id == worktreeId);
         Save();
@@ -366,6 +459,7 @@ public async Task FetchAsync(string repoId, CancellationToken ct = default)
         EnsureLoaded();
         var repo = _state.Repositories.FirstOrDefault(r => r.Id == repoId)
             ?? throw new InvalidOperationException($"Repository '{repoId}' not found.");
+        await EnsureRepoCloneInCurrentRootAsync(repo, null, ct);
         await RunGitAsync(repo.BareClonePath, ct, "fetch", "--prune", "origin");
     }
 
@@ -377,6 +471,7 @@ public async Task<List<string>> GetBranchesAsync(string repoId, CancellationToke
         EnsureLoaded();
         var repo = _state.Repositories.FirstOrDefault(r => r.Id == repoId)
             ?? throw new InvalidOperationException($"Repository '{repoId}' not found.");
+        await EnsureRepoCloneInCurrentRootAsync(repo, null, ct);
         var output = await RunGitAsync(repo.BareClonePath, ct, "branch", "--list");
         return output.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
             .Select(b => b.TrimStart('*').Trim())