fix: use .git/info/exclude instead of .gitignore for worktree exclusions (#434)

PureWeen · Copilot · web-flow · commit adcc3974e307 · 2026-03-25T17:13:47.000-05:00
## Problem

The nested worktree strategy creates `.polypilot/worktrees/` inside the
target repo, then modifies `.gitignore` to hide it. But the `.gitignore`
change itself shows up as an unstaged modification — which CI flags and
confuses users.


## Fix

Replace `.gitignore` modification with `.git/info/exclude` — a
local-only exclusion file that:
- Works identically to `.gitignore` for pattern matching
- Is **never tracked by git** (lives inside `.git/`)
- Doesn't pollute the repo's working tree
- Also handles worktree repos where `.git` is a pointer file (resolves
the real gitdir)

## Tests

Updated all 4 existing tests + added a new test for the worktree gitdir
pointer case. All 5 pass.

---------

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/PolyPilot.Tests/RepoManagerTests.cs b/PolyPilot.Tests/RepoManagerTests.cs
@@ -527,86 +527,184 @@ private static bool PathsEqual(string left, string right)
         return string.Equals(l, r, StringComparison.OrdinalIgnoreCase);
     }
 
-    #region EnsureGitIgnoreEntry Tests
+    #region EnsureGitExcludeEntry Tests
 
     [Fact]
-    public void EnsureGitIgnoreEntry_CreatesGitIgnoreIfMissing()
+    public void EnsureGitExcludeEntry_CreatesExcludeIfMissing()
     {
         var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
         try
         {
-            var method = typeof(RepoManager).GetMethod("EnsureGitIgnoreEntry",
+            // Create a .git/info directory to simulate a real repo
+            var infoDir = Path.Combine(tmpDir, ".git", "info");
+            Directory.CreateDirectory(infoDir);
+
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
                 System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
             method.Invoke(null, [tmpDir, ".polypilot/"]);
 
-            var gitignorePath = Path.Combine(tmpDir, ".gitignore");
-            Assert.True(File.Exists(gitignorePath));
-            var content = File.ReadAllText(gitignorePath);
+            var excludePath = Path.Combine(infoDir, "exclude");
+            Assert.True(File.Exists(excludePath));
+            var content = File.ReadAllText(excludePath);
             Assert.Contains(".polypilot/", content);
         }
         finally { ForceDeleteDirectory(tmpDir); }
     }
 
     [Fact]
-    public void EnsureGitIgnoreEntry_AppendsIfNotPresent()
+    public void EnsureGitExcludeEntry_AppendsIfNotPresent()
     {
         var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
         try
         {
-            var gitignorePath = Path.Combine(tmpDir, ".gitignore");
-            File.WriteAllText(gitignorePath, "*.user\nbin/\n");
+            var infoDir = Path.Combine(tmpDir, ".git", "info");
+            Directory.CreateDirectory(infoDir);
+            var excludePath = Path.Combine(infoDir, "exclude");
+            File.WriteAllText(excludePath, "*.user\nbin/\n");
 
-            var method = typeof(RepoManager).GetMethod("EnsureGitIgnoreEntry",
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
                 System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
             method.Invoke(null, [tmpDir, ".polypilot/"]);
 
-            var content = File.ReadAllText(gitignorePath);
+            var content = File.ReadAllText(excludePath);
             Assert.Contains(".polypilot/", content);
             Assert.Contains("*.user", content); // existing content preserved
         }
         finally { ForceDeleteDirectory(tmpDir); }
     }
 
     [Fact]
-    public void EnsureGitIgnoreEntry_IdempotentIfAlreadyPresent()
+    public void EnsureGitExcludeEntry_IdempotentIfAlreadyPresent()
     {
         var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
         try
         {
-            var gitignorePath = Path.Combine(tmpDir, ".gitignore");
-            File.WriteAllText(gitignorePath, ".polypilot/\n");
+            var infoDir = Path.Combine(tmpDir, ".git", "info");
+            Directory.CreateDirectory(infoDir);
+            var excludePath = Path.Combine(infoDir, "exclude");
+            File.WriteAllText(excludePath, ".polypilot/\n");
 
-            var method = typeof(RepoManager).GetMethod("EnsureGitIgnoreEntry",
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
                 System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
             method.Invoke(null, [tmpDir, ".polypilot/"]);
             method.Invoke(null, [tmpDir, ".polypilot/"]); // call twice
 
-            var lines = File.ReadAllLines(gitignorePath);
+            var lines = File.ReadAllLines(excludePath);
             Assert.Equal(1, lines.Count(l => l.Trim() == ".polypilot/")); // only one entry
         }
         finally { ForceDeleteDirectory(tmpDir); }
     }
 
     [Fact]
-    public void EnsureGitIgnoreEntry_MatchesWithoutTrailingSlash()
+    public void EnsureGitExcludeEntry_MatchesWithoutTrailingSlash()
     {
         var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
         try
         {
-            var gitignorePath = Path.Combine(tmpDir, ".gitignore");
-            File.WriteAllText(gitignorePath, ".polypilot\n"); // no trailing slash variant
+            var infoDir = Path.Combine(tmpDir, ".git", "info");
+            Directory.CreateDirectory(infoDir);
+            var excludePath = Path.Combine(infoDir, "exclude");
+            File.WriteAllText(excludePath, ".polypilot\n"); // no trailing slash variant
 
-            var method = typeof(RepoManager).GetMethod("EnsureGitIgnoreEntry",
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
                 System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
             method.Invoke(null, [tmpDir, ".polypilot/"]);
 
-            var content = File.ReadAllText(gitignorePath);
+            var content = File.ReadAllText(excludePath);
             // Should NOT add a duplicate (already covered by ".polypilot" line)
             Assert.DoesNotContain(".polypilot/", content);
         }
         finally { ForceDeleteDirectory(tmpDir); }
     }
 
+    [Fact]
+    public void EnsureGitExcludeEntry_HandlesWorktreeGitdirPointer()
+    {
+        var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
+        try
+        {
+            // Simulate a worktree where .git is a file pointing to the real gitdir
+            var realGitDir = Path.Combine(tmpDir, "real-gitdir");
+            Directory.CreateDirectory(Path.Combine(realGitDir, "info"));
+            File.WriteAllText(Path.Combine(tmpDir, ".git"), $"gitdir: {realGitDir}\n");
+
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
+            method.Invoke(null, [tmpDir, ".polypilot/"]);
+
+            var excludePath = Path.Combine(realGitDir, "info", "exclude");
+            Assert.True(File.Exists(excludePath));
+            var content = File.ReadAllText(excludePath);
+            Assert.Contains(".polypilot/", content);
+        }
+        finally { ForceDeleteDirectory(tmpDir); }
+    }
+
+    [Fact]
+    public void EnsureGitExcludeEntry_HandlesRelativeGitdirPointer()
+    {
+        var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
+        try
+        {
+            // Simulate a worktree with a relative gitdir pointer (e.g., ../.git/worktrees/name)
+            var bareGitDir = Path.Combine(tmpDir, "bare-repo.git");
+            var worktreeGitDir = Path.Combine(bareGitDir, "worktrees", "my-branch");
+            Directory.CreateDirectory(Path.Combine(worktreeGitDir, "info"));
+
+            var worktreeDir = Path.Combine(tmpDir, "my-worktree");
+            Directory.CreateDirectory(worktreeDir);
+            // Write a relative gitdir pointer
+            var relativePath = Path.GetRelativePath(worktreeDir, worktreeGitDir);
+            File.WriteAllText(Path.Combine(worktreeDir, ".git"), $"gitdir: {relativePath}\n");
+
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
+            method.Invoke(null, [worktreeDir, ".polypilot/"]);
+
+            var excludePath = Path.Combine(worktreeGitDir, "info", "exclude");
+            Assert.True(File.Exists(excludePath));
+            var content = File.ReadAllText(excludePath);
+            Assert.Contains(".polypilot/", content);
+        }
+        finally { ForceDeleteDirectory(tmpDir); }
+    }
+
+    [Fact]
+    public void EnsureGitExcludeEntry_NoGitDirectory_NoOp()
+    {
+        var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
+        try
+        {
+            // No .git file or directory — should be a no-op, not create spurious directories
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
+            method.Invoke(null, [tmpDir, ".polypilot/"]);
+
+            Assert.False(Directory.Exists(Path.Combine(tmpDir, ".git")));
+            Assert.False(File.Exists(Path.Combine(tmpDir, ".git", "info", "exclude")));
+        }
+        finally { ForceDeleteDirectory(tmpDir); }
+    }
+
+    [Fact]
+    public void EnsureGitExcludeEntry_MalformedGitFile_NoOp()
+    {
+        var tmpDir = Directory.CreateTempSubdirectory("polypilot-test-").FullName;
+        try
+        {
+            // .git is a file but doesn't contain gitdir: prefix — should be a no-op
+            File.WriteAllText(Path.Combine(tmpDir, ".git"), "this is not a valid gitdir pointer\n");
+
+            var method = typeof(RepoManager).GetMethod("EnsureGitExcludeEntry",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!;
+            method.Invoke(null, [tmpDir, ".polypilot/"]);
+
+            // Should not have created any info/exclude anywhere
+            Assert.False(Directory.Exists(Path.Combine(tmpDir, ".git", "info")));
+        }
+        finally { ForceDeleteDirectory(tmpDir); }
+    }
+
     #endregion
 
     #region Nested Worktree Path Traversal Tests
diff --git a/PolyPilot/Services/CopilotService.Utilities.cs b/PolyPilot/Services/CopilotService.Utilities.cs
@@ -25,8 +25,30 @@ public partial class CopilotService
         var d = new DirectoryInfo(dir);
         while (d != null)
         {
-            var head = Path.Combine(d.FullName, ".git", "HEAD");
+            var dotGitPath = Path.Combine(d.FullName, ".git");
+
+            // Normal repo: .git is a directory containing HEAD
+            var head = Path.Combine(dotGitPath, "HEAD");
             if (File.Exists(head)) return head;
+
+            // Worktree: .git is a file containing "gitdir: /path/to/real/gitdir"
+            if (File.Exists(dotGitPath))
+            {
+                try
+                {
+                    var firstLine = File.ReadLines(dotGitPath).FirstOrDefault()?.Trim();
+                    if (firstLine != null && firstLine.StartsWith("gitdir:", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var gitdir = firstLine["gitdir:".Length..].Trim();
+                        if (!Path.IsPathRooted(gitdir))
+                            gitdir = Path.GetFullPath(Path.Combine(d.FullName, gitdir));
+                        var worktreeHead = Path.Combine(gitdir, "HEAD");
+                        if (File.Exists(worktreeHead)) return worktreeHead;
+                    }
+                }
+                catch { /* fall through to parent */ }
+            }
+
             d = d.Parent;
         }
         return null;
diff --git a/PolyPilot/Services/CopilotService.cs b/PolyPilot/Services/CopilotService.cs
@@ -2647,6 +2647,18 @@ public async Task<AgentSessionInfo> CreateSessionWithWorktreeAsync(
         {
             var branch = branchName ?? $"session-{DateTime.Now:yyyyMMdd-HHmmss}";
             var remoteName = sessionName ?? branch;
+            // Use repo short name instead of auto-generated session timestamp
+            if (sessionName == null && branch.StartsWith("session-", StringComparison.Ordinal))
+            {
+                var repoInfo = _repoManager.Repositories.FirstOrDefault(r => r.Id == repoId);
+                if (repoInfo != null)
+                {
+                    var shortName = repoInfo.Name.Contains('/')
+                        ? repoInfo.Name[(repoInfo.Name.LastIndexOf('/') + 1)..]
+                        : repoInfo.Name;
+                    remoteName = shortName;
+                }
+            }
 
             // Optimistic local add so the UI shows the session immediately
             var remoteInfo = new AgentSessionInfo { Name = remoteName, Model = model ?? DefaultModel };
@@ -2703,7 +2715,21 @@ await _bridgeClient.CreateSessionWithWorktreeAsync(new CreateSessionWithWorktree
             wt = await _repoManager.CreateWorktreeAsync(repoId, branch, null, localPath: localPath, ct: ct);
         }
 
+        // Derive a friendly display name: prefer explicit sessionName, then branch name,
+        // but fall back to repo short name when the branch is an auto-generated session timestamp.
         var name = sessionName ?? wt.Branch;
+        if (sessionName == null && wt.Branch.StartsWith("session-", StringComparison.Ordinal))
+        {
+            var repoInfo = _repoManager.Repositories.FirstOrDefault(r => r.Id == wt.RepoId);
+            if (repoInfo != null)
+            {
+                // Use last segment of repo name (e.g., "dotnet/maui" → "maui")
+                var shortName = repoInfo.Name.Contains('/')
+                    ? repoInfo.Name[(repoInfo.Name.LastIndexOf('/') + 1)..]
+                    : repoInfo.Name;
+                name = shortName;
+            }
+        }
 
         // Ensure unique session name
         if (_sessions.ContainsKey(name))
diff --git a/PolyPilot/Services/RepoManager.cs b/PolyPilot/Services/RepoManager.cs
@@ -695,7 +695,7 @@ public virtual async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, strin
             // Nested strategy: place worktree inside the user's repo at .polypilot/worktrees/{branch}/
             var repoWorktreesDir = Path.Combine(Path.GetFullPath(localPath), ".polypilot", "worktrees");
             Directory.CreateDirectory(repoWorktreesDir);
-            EnsureGitIgnoreEntry(localPath, ".polypilot/");
+            EnsureGitExcludeEntry(localPath, ".polypilot/");
             worktreePath = Path.Combine(repoWorktreesDir, branchName);
 
             // Guard against path traversal: branch names with ".." or leading "/" could escape
@@ -747,32 +747,69 @@ public virtual async Task<WorktreeInfo> CreateWorktreeAsync(string repoId, strin
 
     /// <summary>
     /// Ensures that <paramref name="entry"/> (e.g. <c>.polypilot/</c>) is present in the
-    /// <c>.gitignore</c> file inside <paramref name="repoPath"/>. Creates <c>.gitignore</c>
-    /// if it does not exist. No-op if the entry is already present.
+    /// <c>.git/info/exclude</c> file inside <paramref name="repoPath"/>. This is a local-only
+    /// exclusion that is never tracked by git, unlike <c>.gitignore</c>.
+    /// Creates the file if it does not exist. No-op if the entry is already present.
     /// </summary>
-    private static void EnsureGitIgnoreEntry(string repoPath, string entry)
+    private static void EnsureGitExcludeEntry(string repoPath, string entry)
     {
         try
         {
-            var gitignorePath = Path.Combine(repoPath, ".gitignore");
-            var lines = File.Exists(gitignorePath)
-                ? File.ReadAllLines(gitignorePath)
+            var dotGitPath = Path.Combine(repoPath, ".git");
+
+            // Early return if no .git file or directory exists (not a valid repo)
+            if (!Directory.Exists(dotGitPath) && !File.Exists(dotGitPath))
+                return;
+
+            var excludePath = Path.Combine(dotGitPath, "info", "exclude");
+            var infoDir = Path.GetDirectoryName(excludePath)!;
+            if (!Directory.Exists(infoDir))
+            {
+                // If .git is a file (worktree), resolve the real gitdir
+                if (File.Exists(dotGitPath))
+                {
+                    var firstLine = File.ReadLines(dotGitPath).FirstOrDefault()?.Trim();
+                    if (firstLine != null && firstLine.StartsWith("gitdir:", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var gitdir = firstLine["gitdir:".Length..].Trim();
+                        if (!Path.IsPathRooted(gitdir))
+                            gitdir = Path.GetFullPath(Path.Combine(repoPath, gitdir));
+                        var resolvedGitdir = Path.GetFullPath(gitdir);
+
+                        // Validate the resolved gitdir is within the repo or a legitimate .git/worktrees/ subtree
+                        var repoFull = Path.GetFullPath(repoPath) + Path.DirectorySeparatorChar;
+                        if (!resolvedGitdir.StartsWith(repoFull, StringComparison.Ordinal)
+                            && !resolvedGitdir.Contains(Path.Combine(".git", "worktrees"), StringComparison.Ordinal))
+                            return;
+
+                        excludePath = Path.Combine(resolvedGitdir, "info", "exclude");
+                        infoDir = Path.GetDirectoryName(excludePath)!;
+                    }
+                    else
+                    {
+                        // Malformed .git file — cannot resolve gitdir
+                        return;
+                    }
+                }
+                Directory.CreateDirectory(infoDir);
+            }
+
+            var lines = File.Exists(excludePath)
+                ? File.ReadAllLines(excludePath)
                 : [];
 
-            // Check if any existing line matches (exact or without trailing slash variant)
             var entryTrimmed = entry.TrimEnd('/');
             if (lines.Any(l => l.Trim() == entry || l.Trim() == entryTrimmed || l.Trim() == $"/{entry}" || l.Trim() == $"/{entryTrimmed}"))
                 return;
 
-            // Append with a leading newline if file doesn't end with one
-            using var sw = new StreamWriter(gitignorePath, append: true);
+            using var sw = new StreamWriter(excludePath, append: true);
             if (lines.Length > 0 && !string.IsNullOrEmpty(lines[^1]))
                 sw.WriteLine();
             sw.WriteLine(entry);
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"[RepoManager] Failed to update .gitignore: {ex.Message}");
+            Console.WriteLine($"[RepoManager] Failed to update .git/info/exclude: {ex.Message}");
         }
     }
 
