From 5c35b15116bc946f8ccf120b6908332dcc917fbd 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 1/5] 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 | 130 +++++++++++++++++
 PolyPilot/Components/Pages/Settings.razor  | 111 ++++++++++++++-
 PolyPilot/Models/ConnectionSettings.cs     |   9 ++
 PolyPilot/Models/RepositoryInfo.cs         |   2 +
 PolyPilot/Services/RepoManager.cs          | 154 +++++++++++++++++----
 6 files changed, 398 insertions(+), 26 deletions(-)
 create mode 100644 PolyPilot.Tests/RepoManagerStorageTests.cs

diff --git a/PolyPilot.Tests/ConnectionSettingsTests.cs b/PolyPilot.Tests/ConnectionSettingsTests.cs
index ffab769199..ddc1e517f6 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..2c25a8df0a
--- /dev/null
+++ b/PolyPilot.Tests/RepoManagerStorageTests.cs
@@ -0,0 +1,130 @@
+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 async Task RecloneAllRepositoriesToCurrentRootAsync_NullBareClonePath_DoesNotThrow()
+    {
+        // Repos with null/empty BareClonePath should not crash EnsureRepoCloneInCurrentRootAsync.
+        // They'll attempt a fresh clone (which will fail without network), but the error is caught
+        // and remaining repos continue processing.
+        var repoWithNullPath = new RepositoryInfo { Id = "owner-repo", BareClonePath = null!, Url = "https://github.com/owner/repo" };
+        var state = new RepositoryState { Repositories = new List<RepositoryInfo> { repoWithNullPath } };
+        var rm = CreateRepoManagerWithState(state);
+        var progressMessages = new List<string>();
+
+        // Should not throw ArgumentNullException even with null BareClonePath
+        await rm.RecloneAllRepositoriesToCurrentRootAsync(msg => progressMessages.Add(msg));
+
+        // A warning progress message is emitted when the clone fails (network unavailable in tests)
+        Assert.Contains(progressMessages, m => m.StartsWith("⚠") || m.Contains("owner-repo") || m.Contains("[1/1]"));
+    }
+
+    [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 730f9f3a98..5ef491fad5 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
@@ -395,6 +396,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">
@@ -556,6 +591,8 @@
     private bool showToken;
     private bool showQrCode;
     private bool showDirectQrCode;
+    private bool recloneBusy;
+    private string? recloneProgress;
     private string? qrCodeDataUri;
     private string? directQrCodeDataUri;
     private List<string> localIps = new();
@@ -566,6 +603,7 @@
     private CliSourceMode _initialCliSource;
     private ConnectionMode _initialMode;
     private bool cliSourceChanged;
+    private string _initialRepositoryStorageRoot = "";
     private int fontSize = 20;
     private string fiestaLinkName = "";
     private string fiestaLinkUrl = "";
@@ -616,7 +654,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"),
             "plugins" => SectionVisible("plugins provider extension dll assembly trust enable disable"),
@@ -712,8 +750,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;
@@ -911,6 +951,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
@@ -1233,6 +1334,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);
@@ -1257,6 +1365,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 cd6d89d9ae..e9a5e995f2 100644
--- a/PolyPilot/Models/ConnectionSettings.cs
+++ b/PolyPilot/Models/ConnectionSettings.cs
@@ -82,6 +82,7 @@ public class ConnectionSettings
     public bool AutoUpdateFromMain { get; set; } = false;
     public CliSourceMode CliSource { get; set; } = CliSourceMode.BuiltIn;
     public VsCodeVariant Editor { get; set; } = VsCodeVariant.Stable;
+    public string? RepositoryStorageRoot { get; set; }
     public List<string> DisabledMcpServers { get; set; } = new();
     public List<string> DisabledPlugins { get; set; } = new();
     public PluginSettings Plugins { get; set; } = new();
@@ -169,6 +170,7 @@ 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);
 
         NormalizeEnumFields(settings);
 
@@ -179,6 +181,13 @@ public static ConnectionSettings Load()
         return settings;
     }
 
+    public static string? NormalizeRepositoryStorageRoot(string? path)
+    {
+        if (string.IsNullOrWhiteSpace(path))
+            return null;
+        return path.Trim();
+    }
+
     /// <summary>Normalize invalid enum values to safe defaults. Testable separately from Load().</summary>
     internal static void NormalizeEnumFields(ConnectionSettings settings)
     {
diff --git a/PolyPilot/Models/RepositoryInfo.cs b/PolyPilot/Models/RepositoryInfo.cs
index 4ec18cb8fc..14bc0e4aeb 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 dc1119b9ea..69f921b08a 100644
--- a/PolyPilot/Services/RepoManager.cs
+++ b/PolyPilot/Services/RepoManager.cs
@@ -7,18 +7,17 @@ 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? _baseDirOverride;
     private static readonly object _pathLock = new();
-    private static string? _reposDir;
-    private static string ReposDir { get { lock (_pathLock) return _reposDir ??= GetReposDir(); } }
-    private static string? _worktreesDir;
-    private static string WorktreesDir { get { lock (_pathLock) return _worktreesDir ??= GetWorktreesDir(); } }
     private static string? _stateFile;
     private static string StateFile { get { lock (_pathLock) return _stateFile ??= GetStateFile(); } }
+    private string ReposDir => Path.Combine(GetStorageRootDir(), "repos");
+    private string WorktreesDir => Path.Combine(GetStorageRootDir(), "worktrees");
 
     /// <summary>
     /// Redirect all RepoManager paths to a test directory.
@@ -29,8 +28,6 @@ internal static void SetBaseDirForTesting(string? path)
         lock (_pathLock)
         {
             _baseDirOverride = path;
-            _reposDir = null;
-            _worktreesDir = null;
             _stateFile = null;
         }
     }
@@ -72,10 +69,24 @@ 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()
+    {
+        // Respect test isolation: if a base dir override is active, skip settings.
+        if (_baseDirOverride != null)
+            return _baseDirOverride;
+        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;
@@ -88,6 +99,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();
             _loadedSuccessfully = true;
         }
         catch (Exception ex)
@@ -302,6 +326,85 @@ 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 (!string.IsNullOrWhiteSpace(repo.BareClonePath)
+            && 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}");
+            try
+            {
+                await EnsureRepoCloneInCurrentRootAsync(repo, onProgress, ct);
+            }
+            catch (OperationCanceledException)
+            {
+                throw; // propagate cancellation
+            }
+            catch (Exception ex)
+            {
+                onProgress?.Invoke($"⚠ {repo.Name}: {ex.Message}");
+                Console.WriteLine($"[RepoManager] RecloneAll: failed for {repo.Id}: {ex.Message}");
+            }
+        }
+    }
+
     /// <summary>
     /// Clone a repository as bare. Returns the RepositoryInfo.
     /// If already tracked, returns existing entry.
@@ -317,20 +420,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))
         {
@@ -397,6 +492,7 @@ public virtual async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, strin
         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)
         if (!skipFetch)
@@ -428,6 +524,7 @@ public virtual async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, strin
             RepoId = repoId,
             Branch = branchName,
             Path = worktreePath,
+            BareClonePath = repo.BareClonePath,
             CreatedAt = DateTime.UtcNow
         };
         lock (_stateLock)
@@ -449,6 +546,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);
 
         // Try to discover the PR's actual head branch name via gh CLI
         string? headBranch = null;
@@ -527,6 +625,7 @@ public async Task<WorktreeInfo> CreateWorktreeFromPrAsync(string repoId, int prN
             RepoId = repoId,
             Branch = branchName,
             Path = worktreePath,
+            BareClonePath = repo.BareClonePath,
             PrNumber = prNumber,
             Remote = remoteName,
             CreatedAt = DateTime.UtcNow
@@ -549,23 +648,28 @@ public async Task RemoveWorktreeAsync(string worktreeId, bool deleteBranch = fal
         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))
                     try { Directory.Delete(wt.Path, recursive: true); } catch { }
-                try { await RunGitAsync(repo.BareClonePath, ct, "worktree", "prune"); } catch { }
+                try { await RunGitAsync(bareClonePath, ct, "worktree", "prune"); } catch { }
             }
             // Optionally clean up the branch too
             if (deleteBranch && !string.IsNullOrEmpty(wt.Branch))
-                try { await RunGitAsync(repo.BareClonePath, ct, "branch", "-D", "--", wt.Branch); } catch { }
+                try { await RunGitAsync(bareClonePath, ct, "branch", "-D", "--", wt.Branch); } catch { }
         }
         else if (Directory.Exists(wt.Path))
         {
@@ -707,6 +811,7 @@ public virtual async Task FetchAsync(string repoId, CancellationToken ct = defau
         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");
     }
 
@@ -718,6 +823,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())

From b94d0f4f036b85fc72f87ef547b5442ff01915de Mon Sep 17 00:00:00 2001
From: "Shane Neuville (HE/HIM)" <shneuvil@microsoft.com>
Date: Sun, 8 Mar 2026 19:04:03 -0500
Subject: [PATCH 2/5] Move CLI Source and Repository Storage into Developer
 settings group

Consolidate infrastructure/tooling settings under the Developer group:
- Move CLI Source from its own 'Copilot CLI' group into Developer
- Move Repository Storage from Connection group into Developer
- Remove the now-empty Copilot CLI group
- Developer group is now always visible (not gated on GitAutoUpdate)
- Update search keywords for the reorganized groups

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 PolyPilot/Components/Pages/Settings.razor | 113 +++++++++++-----------
 PolyPilot/Services/SettingsRegistry.cs    |  50 +++++-----
 2 files changed, 79 insertions(+), 84 deletions(-)

diff --git a/PolyPilot/Components/Pages/Settings.razor b/PolyPilot/Components/Pages/Settings.razor
index 5ef491fad5..96957aada2 100644
--- a/PolyPilot/Components/Pages/Settings.razor
+++ b/PolyPilot/Components/Pages/Settings.razor
@@ -396,40 +396,6 @@
         </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">
@@ -440,46 +406,43 @@
     </div>
     }
 
-    @{ var cliSettings = SettingsRegistry.ForCategory("Copilot CLI", settingsCtx).ToList(); }
-    @if (cliSettings.Any())
-    {
-    <div id="settings-cli" class="settings-group @(CategoryVisible("Copilot CLI") ? "" : "search-hidden")">
-        <h2 class="group-title">Copilot CLI</h2>
+    @{ var uiSettings = SettingsRegistry.ForCategory("UI", settingsCtx).ToList(); }
+    <div id="settings-ui" class="settings-group @(CategoryVisible("UI") ? "" : "search-hidden")">
+        <h2 class="group-title">UI</h2>
         <div class="settings-section">
-            @foreach (var desc in cliSettings)
+            @foreach (var desc in uiSettings)
             {
                 @if (SettingMatchesSearch(desc))
                 {
                     <PolyPilot.Components.Settings.SettingEditor Descriptor="desc" Context="settingsCtx" OnChanged="OnSettingChanged" />
                 }
             }
-            @if (cliSourceChanged)
-            {
-                <div class="cli-restart-hint">⟳ Restart the app to apply the change</div>
-            }
         </div>
     </div>
-    }
 
-    @{ var uiSettings = SettingsRegistry.ForCategory("UI", settingsCtx).ToList(); }
-    <div id="settings-ui" class="settings-group @(CategoryVisible("UI") ? "" : "search-hidden")">
-        <h2 class="group-title">UI</h2>
+    @{ var devSettings = SettingsRegistry.ForCategory("Developer", settingsCtx).ToList(); }
+    <div id="settings-developer" class="settings-group @(GroupVisible("developer") ? "" : "search-hidden")">
+        <h2 class="group-title">Developer</h2>
+
+        @if (devSettings.Any())
+        {
         <div class="settings-section">
-            @foreach (var desc in uiSettings)
+            @foreach (var desc in devSettings)
             {
                 @if (SettingMatchesSearch(desc))
                 {
                     <PolyPilot.Components.Settings.SettingEditor Descriptor="desc" Context="settingsCtx" OnChanged="OnSettingChanged" />
                 }
             }
+            @if (cliSourceChanged)
+            {
+                <div class="cli-restart-hint">⟳ Restart the app to apply the change</div>
+            }
         </div>
-    </div>
-
-    @if (GitAutoUpdate.IsAvailable)
-    {
-    <div id="settings-developer" class="settings-group @(GroupVisible("developer") ? "" : "search-hidden")">
-        <h2 class="group-title">Developer</h2>
+        }
 
+        @if (GitAutoUpdate.IsAvailable)
+        {
         <div class="settings-section @(SectionVisible("auto update main git watch relaunch rebuild") ? "" : "search-hidden")">
             <h3>Auto-Update from Main</h3>
             <p class="section-desc">Watches <code>origin/main</code> for new commits every 30s. When changes are detected, automatically pulls, rebuilds, and relaunches.</p>
@@ -496,8 +459,42 @@
                 }
             </div>
         </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>
-    }
 
     @if (PlatformHelper.IsDesktop)
     {
@@ -654,9 +651,9 @@
         // 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 repository repo clone worktree storage root directory"),
+            "connection" => SectionVisible("transport mode embedded persistent remote server port start stop pid devtunnel share tunnel mobile qr url token connect save reconnect"),
             "ui" => SectionVisible("chat message layout default reversed both left theme font size text zoom"),
-            "developer" => SectionVisible("auto update main git watch relaunch rebuild"),
+            "developer" => SectionVisible("auto update main git watch relaunch rebuild cli source built-in system repository repo clone worktree storage root directory dev drive"),
             "plugins" => SectionVisible("plugins provider extension dll assembly trust enable disable"),
             _ => true
         };
diff --git a/PolyPilot/Services/SettingsRegistry.cs b/PolyPilot/Services/SettingsRegistry.cs
index 6c5039d31d..711216e8a1 100644
--- a/PolyPilot/Services/SettingsRegistry.cs
+++ b/PolyPilot/Services/SettingsRegistry.cs
@@ -135,32 +135,6 @@ private static List<SettingDescriptor> Build()
             SearchKeywords = "save reconnect apply restart",
         });
 
-        // ── Copilot CLI ─────────────────────────────────────────────
-
-        list.Add(new SettingDescriptor
-        {
-            Id = "cli.source",
-            Label = "CLI Source",
-            Description = "Use the CLI bundled with the app or one installed on your system.",
-            Category = "Copilot CLI",
-            Type = SettingType.CardEnum,
-            Order = 10,
-            SearchKeywords = "cli source built-in system version binary copilot",
-            Options = new[]
-            {
-                new SettingOption("BuiltIn", "📦 Built-in"),
-                new SettingOption("System", "💻 System"),
-            },
-            GetValue = ctx => ctx.Settings.CliSource.ToString(),
-            SetValue = (ctx, v) =>
-            {
-                if (v is string s && Enum.TryParse<CliSourceMode>(s, out var src))
-                    ctx.Settings.CliSource = src;
-            },
-            IsVisible = ctx => ctx.Settings.Mode != ConnectionMode.Remote
-                            && ctx.Settings.Mode != ConnectionMode.Demo
-        });
-
         // ── UI ──────────────────────────────────────────────────────
 
         list.Add(new SettingDescriptor
@@ -373,6 +347,30 @@ private static List<SettingDescriptor> Build()
 
         // ── Developer ───────────────────────────────────────────────
 
+        list.Add(new SettingDescriptor
+        {
+            Id = "cli.source",
+            Label = "CLI Source",
+            Description = "Use the CLI bundled with the app or one installed on your system.",
+            Category = "Developer",
+            Type = SettingType.CardEnum,
+            Order = 5,
+            SearchKeywords = "cli source built-in system version binary copilot",
+            Options = new[]
+            {
+                new SettingOption("BuiltIn", "📦 Built-in"),
+                new SettingOption("System", "💻 System"),
+            },
+            GetValue = ctx => ctx.Settings.CliSource.ToString(),
+            SetValue = (ctx, v) =>
+            {
+                if (v is string s && Enum.TryParse<CliSourceMode>(s, out var src))
+                    ctx.Settings.CliSource = src;
+            },
+            IsVisible = ctx => ctx.Settings.Mode != ConnectionMode.Remote
+                            && ctx.Settings.Mode != ConnectionMode.Demo
+        });
+
         list.Add(new SettingDescriptor
         {
             Id = "developer.autoUpdate",

From cb4f45e3855d85d5e38605b1e97e733c8d177dde Mon Sep 17 00:00:00 2001
From: "Shane Neuville (HE/HIM)" <shneuvil@microsoft.com>
Date: Sun, 8 Mar 2026 22:43:49 -0500
Subject: [PATCH 3/5] fix: show Developer nav when storage settings available,
 add GTK FolderPicker guard

- Developer nav button now shows when GitAutoUpdate.IsAvailable OR PlatformHelper.IsDesktop
- BrowseRepositoryStorageRoot() wrapped in #if MACCATALYST || WINDOWS for GTK compat

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 PolyPilot/Components/Pages/Settings.razor | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/PolyPilot/Components/Pages/Settings.razor b/PolyPilot/Components/Pages/Settings.razor
index 96957aada2..55947589cc 100644
--- a/PolyPilot/Components/Pages/Settings.razor
+++ b/PolyPilot/Components/Pages/Settings.razor
@@ -55,7 +55,7 @@
                 <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"/><line x1="3" y1="9" x2="21" y2="9"/><line x1="9" y1="21" x2="9" y2="9"/></svg>
                 UI
             </button>
-            @if (GitAutoUpdate.IsAvailable)
+            @if (GitAutoUpdate.IsAvailable || PlatformHelper.IsDesktop)
             {
                 <button class="settings-nav-item @(activeCategory == "developer" ? "active" : "")" @onclick='() => ScrollToCategory("developer")'>
                     <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg>
@@ -964,9 +964,13 @@
 
     private async Task BrowseRepositoryStorageRoot()
     {
+#if MACCATALYST || WINDOWS
         var dir = await FolderPickerService.PickFolderAsync();
         if (!string.IsNullOrWhiteSpace(dir))
             settings.RepositoryStorageRoot = dir;
+#else
+        await Task.CompletedTask;
+#endif
     }
 
     private void UseDefaultRepositoryStorageRoot()

From 97236a1b21c7f6b077c8bb12f3f60522656e4707 Mon Sep 17 00:00:00 2001
From: vitek-karas <10670590+vitek-karas@users.noreply.github.com>
Date: Mon, 9 Mar 2026 20:04:34 +0100
Subject: [PATCH 4/5] fix: improve Repository Storage settings UI layout and
 behavior

- Add spacing between input and action buttons (margin-top on actions)
- Fix Use Default button to reliably clear input (use empty string)
- Add GetDefaultStorageRoot() to show true default path in placeholder
- Style placeholder text as italic with reduced opacity for clarity
- Add margin-top to settings-field for consistent section spacing
- Change Use Default button from red (stop-btn) to green (start-btn)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 PolyPilot/Components/Pages/Settings.razor     | 18 ++++----
 PolyPilot/Components/Pages/Settings.razor.css | 45 +++++++++++++++++++
 PolyPilot/Services/RepoManager.cs             |  5 +++
 3 files changed, 60 insertions(+), 8 deletions(-)

diff --git a/PolyPilot/Components/Pages/Settings.razor b/PolyPilot/Components/Pages/Settings.razor
index f4a14689ba..c6831aa75b 100644
--- a/PolyPilot/Components/Pages/Settings.razor
+++ b/PolyPilot/Components/Pages/Settings.razor
@@ -487,13 +487,15 @@
         <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 class="settings-field">
+                <label for="repository-storage-root">Storage Root</label>
+                <div class="settings-field-body">
+                    <input id="repository-storage-root" type="text" @bind="settings.RepositoryStorageRoot" placeholder="Default: @RepoManager.GetDefaultStorageRoot()" class="form-input wide" />
+                    <div class="settings-field-actions">
+                        <button class="start-btn" @onclick="BrowseRepositoryStorageRoot">Browse…</button>
+                        <button class="start-btn" @onclick="UseDefaultRepositoryStorageRoot">Use Default</button>
+                    </div>
+                </div>
             </div>
             @if (RepositoryStorageRootChanged)
             {
@@ -996,7 +998,7 @@
 
     private void UseDefaultRepositoryStorageRoot()
     {
-        settings.RepositoryStorageRoot = null;
+        settings.RepositoryStorageRoot = "";
     }
 
     private async Task RecloneAllRegisteredRepos()
diff --git a/PolyPilot/Components/Pages/Settings.razor.css b/PolyPilot/Components/Pages/Settings.razor.css
index 04a6723b53..a1409234a6 100644
--- a/PolyPilot/Components/Pages/Settings.razor.css
+++ b/PolyPilot/Components/Pages/Settings.razor.css
@@ -345,6 +345,12 @@
     border-color: var(--accent-primary);
 }
 
+.form-input::placeholder {
+    color: var(--text-secondary, #888);
+    opacity: 0.55;
+    font-style: italic;
+}
+
 .server-status {
     display: flex;
     align-items: center;
@@ -814,6 +820,35 @@
     white-space: nowrap;
 }
 
+.settings-field {
+    display: grid;
+    grid-template-columns: minmax(120px, max-content) minmax(0, 1fr);
+    gap: 0.75rem 1rem;
+    align-items: start;
+    margin-top: 0.75rem;
+}
+
+.settings-field > label {
+    color: var(--text-on-surface);
+    font-size: var(--type-body);
+    line-height: 1.4;
+    padding-top: 0.45rem;
+}
+
+.settings-field-body {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+    min-width: 0;
+}
+
+.settings-field-actions {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+    margin-top: 0.25rem;
+}
+
 .form-input.wide {
     flex: 1;
     max-width: none;
@@ -1084,6 +1119,16 @@
         font-size: var(--type-callout);
     }
 
+    .settings-field {
+        grid-template-columns: 1fr;
+        gap: 0.35rem;
+    }
+
+    .settings-field > label {
+        font-size: var(--type-callout);
+        padding-top: 0;
+    }
+
     .form-input {
         font-size: var(--type-callout);
         padding: 0.35rem 0.5rem;
diff --git a/PolyPilot/Services/RepoManager.cs b/PolyPilot/Services/RepoManager.cs
index 69f921b08a..c1b55646db 100644
--- a/PolyPilot/Services/RepoManager.cs
+++ b/PolyPilot/Services/RepoManager.cs
@@ -328,6 +328,11 @@ public static string NormalizeRepoUrl(string input)
 
     public string GetEffectiveStorageRoot() => GetStorageRootDir();
 
+    /// <summary>
+    /// Returns the default storage root (ignoring any user-configured override).
+    /// </summary>
+    public static string GetDefaultStorageRoot() => GetBaseDir();
+
     private string GetDesiredBareClonePath(string repoId) => Path.Combine(ReposDir, $"{repoId}.git");
 
     private static bool PathsEqual(string left, string right)

From 6ae0cf9e78aae2f470a1d295e149d1461662492c Mon Sep 17 00:00:00 2001
From: Shane Neuville <shneuvil@microsoft.com>
Date: Mon, 9 Mar 2026 22:41:01 -0500
Subject: [PATCH 5/5] fix: cache storage root, add thread safety for repo state
 mutations

- Cache GetStorageRootDir() result to avoid ConnectionSettings.Load() disk I/O
  on every ReposDir/WorktreesDir access (was ~10 calls per operation)
- Add InvalidateStorageRoot() for settings changes in Settings.razor
- Add _stateLock protection around BareClonePath mutations and Save()
  in EnsureRepoCloneInCurrentRootAsync
- Wrap BackfillWorktreeClonePaths iteration with _stateLock
- Clear _storageRoot in SetBaseDirForTesting for test isolation

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 PolyPilot/Components/Pages/Settings.razor |  2 ++
 PolyPilot/Services/RepoManager.cs         | 32 ++++++++++++++++++-----
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/PolyPilot/Components/Pages/Settings.razor b/PolyPilot/Components/Pages/Settings.razor
index c6831aa75b..af3cc98338 100644
--- a/PolyPilot/Components/Pages/Settings.razor
+++ b/PolyPilot/Components/Pages/Settings.razor
@@ -1011,6 +1011,7 @@
         }
 
         settings.Save();
+        RepoManager.InvalidateStorageRoot();
         recloneBusy = true;
         recloneProgress = null;
         StateHasChanged();
@@ -1382,6 +1383,7 @@
             settings.RemoteUrl = ConnectionSettings.NormalizeRemoteUrl(settings.RemoteUrl);
 
         settings.Save();
+        RepoManager.InvalidateStorageRoot();
         ShowStatus("Settings saved. Reconnecting...", "", 0);
 
         try
diff --git a/PolyPilot/Services/RepoManager.cs b/PolyPilot/Services/RepoManager.cs
index 069e05f1df..81624839a0 100644
--- a/PolyPilot/Services/RepoManager.cs
+++ b/PolyPilot/Services/RepoManager.cs
@@ -15,9 +15,10 @@ public class RepoManager
     private static string? _baseDirOverride;
     private static readonly object _pathLock = new();
     private static string? _stateFile;
+    private static string? _storageRoot;
     private static string StateFile { get { lock (_pathLock) return _stateFile ??= GetStateFile(); } }
-    private string ReposDir => Path.Combine(GetStorageRootDir(), "repos");
-    private string WorktreesDir => Path.Combine(GetStorageRootDir(), "worktrees");
+    private string ReposDir => Path.Combine(GetCachedStorageRoot(), "repos");
+    private string WorktreesDir => Path.Combine(GetCachedStorageRoot(), "worktrees");
 
     /// <summary>
     /// Redirect all RepoManager paths to a test directory.
@@ -29,6 +30,7 @@ internal static void SetBaseDirForTesting(string? path)
         {
             _baseDirOverride = path;
             _stateFile = null;
+            _storageRoot = null;
         }
     }
 
@@ -87,6 +89,20 @@ private static string GetStorageRootDir()
         return GetBaseDir();
     }
 
+    private static string GetCachedStorageRoot()
+    {
+        lock (_pathLock)
+            return _storageRoot ??= GetStorageRootDir();
+    }
+
+    /// <summary>
+    /// Call when settings change (e.g., RepositoryStorageRoot) to pick up the new value.
+    /// </summary>
+    public static void InvalidateStorageRoot()
+    {
+        lock (_pathLock) _storageRoot = null;
+    }
+
     public void Load()
     {
         _loaded = true;
@@ -326,7 +342,7 @@ public static string NormalizeRepoUrl(string input)
         return input;
     }
 
-    public string GetEffectiveStorageRoot() => GetStorageRootDir();
+    public string GetEffectiveStorageRoot() => GetCachedStorageRoot();
 
     /// <summary>
     /// Returns the default storage root (ignoring any user-configured override).
@@ -358,7 +374,7 @@ private async Task EnsureRepoCloneInCurrentRootAsync(RepositoryInfo repo, Action
             && Directory.Exists(targetBarePath))
             return;
 
-        BackfillWorktreeClonePaths(repo);
+        lock (_stateLock) BackfillWorktreeClonePaths(repo);
         Directory.CreateDirectory(ReposDir);
 
         if (Directory.Exists(targetBarePath))
@@ -381,8 +397,12 @@ private async Task EnsureRepoCloneInCurrentRootAsync(RepositoryInfo repo, Action
             try { await RunGitAsync(targetBarePath, ct, "config", "core.longpaths", "true"); } catch { }
         }
 
-        repo.BareClonePath = targetBarePath;
-        Save();
+        lock (_stateLock)
+        {
+            repo.BareClonePath = targetBarePath;
+            BackfillWorktreeClonePaths(repo);
+            Save();
+        }
         OnStateChanged?.Invoke();
     }