feat(worker): company unit roots start from a fetched origin base, local base fast-forwarded best-effort

src/ClaudeDo.Worker/Runner/WorktreeManager.cs

@@ -2,6 +2,7 @@ using ClaudeDo.Data;
 using ClaudeDo.Data.Git;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.AzureDevOps;
 using ClaudeDo.Worker.Config;
 using ClaudeDo.Worker.Git;
 using ClaudeDo.Worker.Hub;
@@ -24,16 +25,18 @@ public sealed class WorktreeManager
     private readonly WorkerConfig _cfg;
     private readonly ILogger<WorktreeManager> _logger;
     private readonly HubBroadcaster? _broadcaster;
+    private readonly AzureDevOpsClient? _azdo;
 
     public WorktreeManager(
         GitService git, IDbContextFactory<ClaudeDoDbContext> dbFactory, WorkerConfig cfg,
-        ILogger<WorktreeManager> logger, HubBroadcaster? broadcaster = null)
+        ILogger<WorktreeManager> logger, HubBroadcaster? broadcaster = null, AzureDevOpsClient? azdo = null)
     {
         _git = git;
         _dbFactory = dbFactory;
         _cfg = cfg;
         _logger = logger;
         _broadcaster = broadcaster;
+        _azdo = azdo;
     }
 
     private Task BroadcastCreating(string taskId) =>
@@ -76,8 +79,8 @@ public sealed class WorktreeManager
         if (await _git.EnsureHeadCommitAsync(workingDir, ct))
             _logger.LogInformation("Repository at {Dir} had no commits; created an empty bootstrap commit", workingDir);
 
-        var baseCommit = await ResolveBaseCommitAsync(task, workingDir, ct);
         var isCompany = await CompanyRepo.IsCompanyAsync(_git, workingDir, _cfg.CompanyRemotePattern, ct);
+        var baseCommit = await ResolveBaseCommitAsync(task, workingDir, isCompany, ct);
         var name = NameFor(task, await ResolveTicketIdAsync(task, ct), isCompany);
         var branchType = BranchTypeFor(task.CommitType);
         var slug = CommitMessageBuilder.ToSlug(list.Name);
@@ -261,9 +264,10 @@ public sealed class WorktreeManager
     /// <summary>
     /// A child of a parent with an Active worktree starts from the unit branch's current head, so it
     /// sees every sibling absorbed before it. Unit roots (and legacy children) base off
-    /// <c>list_config.base_branch</c>, else the current HEAD.
+    /// <c>list_config.base_branch</c>, else the current HEAD — in a company repo off a freshly fetched
+    /// <c>origin/&lt;basis&gt;</c> (<see cref="FetchCompanyBaseAsync"/>).
     /// </summary>
-    private async Task<string> ResolveBaseCommitAsync(TaskEntity task, string workingDir, CancellationToken ct)
+    private async Task<string> ResolveBaseCommitAsync(TaskEntity task, string workingDir, bool isCompany, CancellationToken ct)
     {
         if (task.ParentTaskId is not null)
         {
@@ -273,12 +277,83 @@ public sealed class WorktreeManager
                 return await _git.RevParseAsync(workingDir, parentWt.BranchName, ct);
         }
         using var cfgCtx = _dbFactory.CreateDbContext();
-        var baseBranch = await cfgCtx.ListConfigs.AsNoTracking()
+        var baseBranch = (await cfgCtx.ListConfigs.AsNoTracking()
             .Where(c => c.ListId == task.ListId)
             .Select(c => c.BaseBranch)
-            .FirstOrDefaultAsync(ct);
-        return string.IsNullOrWhiteSpace(baseBranch)
+            .FirstOrDefaultAsync(ct)).NullIfBlank();
+
+        if (isCompany && await FetchCompanyBaseAsync(workingDir, baseBranch, ct) is { } fetched)
+            return fetched;
+
+        return baseBranch is null
             ? await _git.RevParseHeadAsync(workingDir, ct)
             : await _git.RevParseAsync(workingDir, baseBranch, ct);
     }
+
+    /// <summary>
+    /// Fetches the basis (<c>base_branch</c>, else the ADO repo's default branch, else <c>origin/HEAD</c>) and
+    /// returns <c>origin/&lt;basis&gt;</c>'s commit; the local basis is fast-forwarded best-effort. Null when no
+    /// basis is known or the fetch failed (offline, no credentials) — the caller then uses the local basis,
+    /// a fetch problem never fails the task.
+    /// </summary>
+    private async Task<string?> FetchCompanyBaseAsync(string workingDir, string? baseBranch, CancellationToken ct)
+    {
+        var remote = await _git.GetRemoteUrlAsync(workingDir, "origin", ct);
+        var pat = _azdo?.Pat;
+        var basis = baseBranch;
+        if (basis is null && _azdo is not null && pat is not null && AzureDevOpsClient.ParseRemote(remote) is { } repo)
+        {
+            try { basis = await _azdo.GetDefaultBranchAsync(repo, ct); }
+            catch (AzureDevOpsException ex) { _logger.LogWarning("Default branch from Azure DevOps unavailable: {reason}", ex.Message); }
+        }
+        basis ??= await _git.GetRemoteHeadBranchAsync(workingDir, ct);
+        if (basis is null)
+        {
+            _logger.LogWarning("Company repo {working_dir}: no base branch known, worktree starts from HEAD without fetch", workingDir);
+            return null;
+        }
+
+        var (fetchExit, fetchErr) = await _git.FetchBranchAsync(workingDir, basis, AzureDevOpsClient.GitAuthEnv(pat), ct);
+        if (fetchExit != 0)
+        {
+            _logger.LogWarning("git fetch origin {branch} failed in {working_dir}, continuing with the local branch: {reason}",
+                basis, workingDir, fetchErr);
+            return baseBranch is null ? await TryRevParseAsync(workingDir, basis, ct) : null;
+        }
+
+        await FastForwardLocalBaseAsync(workingDir, basis, ct);
+        return await _git.RevParseAsync(workingDir, $"refs/remotes/origin/{basis}", ct);
+    }
+
+    /// <summary>Pulls the local basis up to <c>origin/&lt;basis&gt;</c> without ever touching a dirty or diverged checkout.</summary>
+    private async Task FastForwardLocalBaseAsync(string workingDir, string basis, CancellationToken ct)
+    {
+        string? current;
+        try { current = await _git.GetCurrentBranchAsync(workingDir, ct); }
+        catch (InvalidOperationException) { current = null; } // detached HEAD
+
+        (int ExitCode, string Stderr) result;
+        if (current == basis)
+        {
+            if (await _git.HasChangesAsync(workingDir, includeUntracked: false, ct))
+            {
+                _logger.LogWarning("Local {branch} in {working_dir} has uncommitted changes, not fast-forwarded to origin", basis, workingDir);
+                return;
+            }
+            result = await _git.MergeFastForwardOnlyAsync(workingDir, $"refs/remotes/origin/{basis}", ct);
+        }
+        else
+        {
+            if (!(await _git.ListLocalBranchesAsync(workingDir, ct)).Contains(basis)) return;
+            result = await _git.FastForwardLocalBranchAsync(workingDir, basis, ct);
+        }
+        if (result.ExitCode != 0)
+            _logger.LogWarning("Local {branch} in {working_dir} not fast-forwarded to origin: {reason}", basis, workingDir, result.Stderr);
+    }
+
+    private async Task<string?> TryRevParseAsync(string workingDir, string revision, CancellationToken ct)
+    {
+        try { return await _git.RevParseAsync(workingDir, revision, ct); }
+        catch (InvalidOperationException) { return null; }
+    }
 }