hooks: resolve enlistment root for worktrees outside enlistment tree

All native hooks (virtual-filesystem, read-object, post-index-changed)
and managed hooks (GVFS.Hooks) resolved the primary enlistment root by
walking up from CWD looking for a .gvfs/ directory. This meant worktrees
placed outside the enlistment directory tree (e.g. in a temp directory
or as a sibling) could not use git commands — the hooks would fail with
'must be run from inside a GVFS enlistment'.

Fix by adding a worktree fallback path: when .gvfs walk-up fails, walk
up looking for a .git file (indicating a linked worktree), then resolve
the primary enlistment root through the gitdir chain — first from the
gvfs-enlistment-root marker file, then by deriving from commondir.
The resolved root is validated by checking that .gvfs/ exists there.

Native hooks (common.windows.cpp):
- Extract ReadFirstLine, Utf8ToWide, TryParseGitFile helpers
- Refactor GetWorktreePipeSuffix to use shared helpers
- Add TryResolveFromWorktree that returns both enlistment root and
  pipe suffix
- GetGVFSPipeName tries .gvfs walk-up first, then worktree fallback

Managed hooks (Program.cs):
- After TryGetGVFSEnlistmentRoot fails, try TryGetWorktreeInfo ->
  GetEnlistmentRoot() before exiting
- Validate .gvfs exists at the resolved root

Tests:
- Unit tests for GetEnlistmentRoot with marker file, SharedGitDir
  fallback, and marker-preferred scenarios
- Functional test creating worktree in temp directory, verifying
  git status from root and subdirectory, file projection, commits

Assisted-by: Claude Opus 4.6
Signed-off-by: Ty Larrabee <tyrielv@gmail.com>

Author: tyrielv

GVFS/GVFS.FunctionalTests/Tests/EnlistmentPerFixture/WorktreeTests.cs

@@ -191,6 +191,83 @@ public void ConcurrentWorktreeAddCommitRemove()
             }
         }
 
+        [TestCase]
+        public void WorktreeOutsideEnlistmentTree()
+        {
+            string suffix = Guid.NewGuid().ToString("N").Substring(0, 8);
+            string tempDir = Path.Combine(Path.GetTempPath(), $"gvfs-remote-wt-{suffix}");
+            string worktreePath = Path.Combine(tempDir, "wt");
+            string branchName = $"remote-wt-test-{suffix}";
+
+            try
+            {
+                Directory.CreateDirectory(tempDir);
+
+                // 1. Create worktree outside the enlistment tree
+                ProcessResult addResult = GitHelpers.InvokeGitAgainstGVFSRepo(
+                    this.Enlistment.RepoRoot,
+                    $"worktree add -b {branchName} \"{worktreePath}\"");
+                addResult.ExitCode.ShouldEqual(0,
+                    $"worktree add failed: {addResult.Errors}");
+
+                // 2. Verify GVFS mount is running
+                this.AssertWorktreeMounted(worktreePath, "remote worktree");
+
+                // 3. Verify git status works from the worktree root
+                ProcessResult statusResult = GitHelpers.InvokeGitAgainstGVFSRepo(
+                    worktreePath, "status --porcelain");
+                statusResult.ExitCode.ShouldEqual(0,
+                    $"git status from worktree root failed: {statusResult.Errors}");
+                statusResult.Output.Trim().ShouldBeEmpty(
+                    "Remote worktree should have clean status");
+
+                // 4. Verify projected files are visible
+                File.Exists(Path.Combine(worktreePath, "Readme.md")).ShouldBeTrue(
+                    "Readme.md should be projected in remote worktree");
+
+                // 5. Verify git status works from a subdirectory
+                string subDir = Path.Combine(worktreePath, "GVFS");
+                Directory.Exists(subDir).ShouldBeTrue(
+                    "Subdirectory GVFS should be projected");
+                ProcessResult subDirStatus = GitHelpers.InvokeGitAgainstGVFSRepo(
+                    subDir, "status --porcelain");
+                subDirStatus.ExitCode.ShouldEqual(0,
+                    $"git status from subdirectory failed: {subDirStatus.Errors}");
+
+                // 6. Verify commits work
+                File.WriteAllText(
+                    Path.Combine(worktreePath, "remote-test.txt"),
+                    "created in remote worktree");
+                GitHelpers.InvokeGitAgainstGVFSRepo(worktreePath, "add remote-test.txt")
+                    .ExitCode.ShouldEqual(0);
+                GitHelpers.InvokeGitAgainstGVFSRepo(
+                    worktreePath, "commit -m \"commit from remote worktree\"")
+                    .ExitCode.ShouldEqual(0);
+
+                // 7. Verify commit is visible from primary repo
+                GitHelpers.InvokeGitAgainstGVFSRepo(
+                    this.Enlistment.RepoRoot, $"log -1 --format=%s {branchName}")
+                    .Output.ShouldContain(expectedSubstrings: new[] { "commit from remote worktree" });
+
+                // 8. Remove worktree
+                ProcessResult removeResult = GitHelpers.InvokeGitAgainstGVFSRepo(
+                    this.Enlistment.RepoRoot,
+                    $"worktree remove --force \"{worktreePath}\"");
+                removeResult.ExitCode.ShouldEqual(0,
+                    $"worktree remove failed: {removeResult.Errors}");
+                Directory.Exists(worktreePath).ShouldBeFalse(
+                    "Remote worktree directory should be deleted");
+            }
+            finally
+            {
+                this.ForceCleanupWorktree(worktreePath, branchName);
+                if (Directory.Exists(tempDir))
+                {
+                    try { Directory.Delete(tempDir, recursive: true); } catch { }
+                }
+            }
+        }
+
         private void InitWorktreeArrays(int count, out string[] paths, out string[] branches)
         {
             paths = new string[count];

GVFS/GVFS.Hooks/Program.cs

@@ -3,6 +3,7 @@
 using GVFS.Common.NamedPipes;
 using GVFS.Common.Tracing;
 using GVFS.Hooks.HooksPlatform;
+using GVFS.Platform.Windows;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -47,9 +48,21 @@ public static void Main(string[] args)
 
                 if (!GVFSHooksPlatform.TryGetGVFSEnlistmentRoot(Environment.CurrentDirectory, out enlistmentRoot, out errorMessage))
                 {
-                    // Nothing to hook when being run outside of a GVFS repo.
-                    // This is also the path when run with --git-dir outside of a GVFS directory, see Story #949665
-                    Environment.Exit(0);
+                    // .gvfs walk-up failed — this may be a worktree placed
+                    // outside the primary enlistment tree. Try resolving
+                    // the enlistment root through the worktree chain.
+                    GVFSEnlistment.WorktreeInfo wtInfo = GVFSEnlistment.TryGetWorktreeInfo(normalizedCurrentDirectory);
+                    if (wtInfo != null)
+                    {
+                        enlistmentRoot = wtInfo.GetEnlistmentRoot();
+                    }
+
+                    if (enlistmentRoot == null ||
+                        !Directory.Exists(Path.Combine(enlistmentRoot, WindowsPlatform.DotGVFSRoot)))
+                    {
+                        // Not in a GVFS repo or worktree. Nothing to hook.
+                        Environment.Exit(0);
+                    }
                 }
 
                 enlistmentPipename = GVFSHooksPlatform.GetNamedPipeName(enlistmentRoot);