diff --git a/.editorconfig b/.editorconfig
index c04a279..92356f0 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -9,7 +9,9 @@ charset = utf-8
 indent_style = space
 indent_size = 4
 tab_width = 4
-end_of_line = crlf
+# LF on every platform, matching the `* text=auto eol=lf` default in .gitattributes.
+# Overrides below must stay in step with the eol pins in that file.
+end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 
@@ -503,4 +505,9 @@ indent_style = tab
 # Shell scripts
 [*.sh]
 end_of_line = lf
-indent_size = 2
\ No newline at end of file
+indent_size = 2
+
+# Windows batch scripts and Visual Studio solution files keep CRLF on every platform.
+# These match the eol=crlf pins in .gitattributes.
+[*.{cmd,bat,sln}]
+end_of_line = crlf
\ No newline at end of file
diff --git a/.gitattributes b/.gitattributes
index d67e40c..a0bea35 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -4,20 +4,25 @@
 # Git Line Endings            #
 ###############################
 
-# Set default behaviour to automatically normalize line endings.
-* text=auto
+# Normalize all text files to LF in the repository, and check them out as LF on every
+# platform. The explicit eol overrides each machine's core.autocrlf, so the working tree
+# is byte-identical on Windows, Linux and macOS. This must stay in step with the
+# end_of_line settings in .editorconfig.
+* text=auto eol=lf
 
-# csharp files to match .editorconfig
-*.cs text eol=crlf
+# Force bash scripts to always use LF line endings so that if a repo is accessed
+# in Unix via a file share from Windows, the scripts will work. Redundant with the
+# default above, kept explicit because these files break outright with CRLF.
+*.sh text eol=lf
 
 # Force batch scripts to always use CRLF line endings so that if a repo is accessed
 # in Windows via a file share from Linux, the scripts will work.
-*.{cmd,[cC][mM][dD]} text eol=crlf
-*.{bat,[bB][aA][tT]} text eol=crlf
+*.cmd text eol=crlf
+*.bat text eol=crlf
 
-# Force bash scripts to always use LF line endings so that if a repo is accessed
-# in Unix via a file share from Windows, the scripts will work.
-*.sh text eol=lf
+# Visual Studio rewrites solution files with CRLF regardless of the checkout, so pin
+# them to avoid a spurious whole-file diff every time the solution is opened.
+*.sln text eol=crlf
 
 ###############################
 # Git Large File System (LFS) #
diff --git a/.runsettings b/.runsettings
index 3c3169d..9bd9f05 100644
--- a/.runsettings
+++ b/.runsettings
@@ -1,25 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <RunSettings>
-  <!-- Specify a deterministic output directory -->
   <RunConfiguration>
-    <ResultsDirectory>.\coverage</ResultsDirectory>
+    <ResultsDirectory>TestResults</ResultsDirectory>
   </RunConfiguration>
-  <!-- Specify a deterministic output directory -->
-  <RunConfiguration>
-    <ResultsDirectory>.\coverage</ResultsDirectory>
-  </RunConfiguration>
-
-  <!-- Configuration for coverlet data collector -->
-  <DataCollectionRunSettings>
-    <DataCollectors>
-      <DataCollector friendlyName="XPlat Code Coverage" uri="datacollector://Microsoft/CodeCoverage/2.0" assemblyQualifiedName="coverlet.collector.DataCollectors.CoverletInProcDataCollector, coverlet.collector, Version=6.0.4.0, Culture=neutral, PublicKeyToken=null">
-        <Configuration>
-          <Format>opencover</Format>
-          <OutputPath>coverage.opencover.xml</OutputPath>
-          <Exclude>[*Test*]*,[*Tests*]*</Exclude>
-          <ExcludeByFile>**/obj/**/*</ExcludeByFile>
-        </Configuration>
-      </DataCollector>
-    </DataCollectors>
-  </DataCollectionRunSettings>
 </RunSettings>
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 4e36445..cf11ee7 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -11,7 +11,6 @@
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.10" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.10" />
     <!-- Git and GitHub -->
-    <PackageVersion Include="LibGit2Sharp" Version="0.32.0" />
     <PackageVersion Include="Octokit" Version="14.0.0" />
     <!-- Diff and Merge -->
     <PackageVersion Include="DiffPlex" Version="1.9.0" />
@@ -27,7 +26,7 @@
     <PackageVersion Include="ktsu.IntervalAction" Version="1.3.10" />
     <PackageVersion Include="ktsu.AppDataStorage" Version="1.16.21" />
     <PackageVersion Include="ktsu.Extensions" Version="1.5.14" />
-    <PackageVersion Include="ktsu.RunCommand" Version="1.4.5" />
+    <PackageVersion Include="ktsu.RunCommand" Version="1.4.26" />
     <PackageVersion Include="ktsu.Frontmatter" Version="1.2.10" />
     <PackageVersion Include="ktsu.TextFilter" Version="1.5.9" />
     <PackageVersion Include="ktsu.Semantics.Paths" Version="1.1.0" />
@@ -36,7 +35,7 @@
     <!-- SDK-required packages -->
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="10.0.301" />
     <PackageVersion Include="Microsoft.SourceLink.AzureRepos.Git" Version="10.0.301" />
-    <PackageVersion Include="Polyfill" Version="10.8.1" />
+    <PackageVersion Include="Polyfill" Version="11.0.2" />
     <!-- Testing -->
     <!-- MSTest.TestAdapter, MSTest.TestFramework and Microsoft.Testing.Extensions.CodeCoverage
          are supplied by MSTest.Sdk (pinned in global.json). Declaring them here as well makes
diff --git a/KtsuTools.Core/KtsuTools.Core.csproj b/KtsuTools.Core/KtsuTools.Core.csproj
index 11bf2d4..ca2a427 100644
--- a/KtsuTools.Core/KtsuTools.Core.csproj
+++ b/KtsuTools.Core/KtsuTools.Core.csproj
@@ -11,7 +11,6 @@
     <PackageReference Include="Spectre.Console" />
     <PackageReference Include="Spectre.Console.Ansi" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
-    <PackageReference Include="LibGit2Sharp" />
     <PackageReference Include="Octokit" />
     <PackageReference Include="ktsu.AppDataStorage" />
     <PackageReference Include="ktsu.CredentialCache" />
diff --git a/KtsuTools.Core/Services/Git/GitService.cs b/KtsuTools.Core/Services/Git/GitService.cs
index 797f4c9..2f08ef1 100644
--- a/KtsuTools.Core/Services/Git/GitService.cs
+++ b/KtsuTools.Core/Services/Git/GitService.cs
@@ -6,114 +6,82 @@ namespace KtsuTools.Core.Services.Git;
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using LibGit2Sharp;
 
 public class GitService : IGitService
 {
-	public Task<bool> PullAsync(string repoPath, CancellationToken ct = default) =>
-		Task.Run(() =>
-		{
-			try
-			{
-				using Repository repo = new(repoPath);
-				Signature signature = repo.Config.BuildSignature(DateTimeOffset.Now);
-				PullOptions options = new()
-				{
-					FetchOptions = new FetchOptions(),
-				};
-				Commands.Pull(repo, signature, options);
-				return true;
-			}
-			catch (LibGit2SharpException)
-			{
-				return false;
-			}
-		}, ct);
+	public async Task<bool> PullAsync(string repoPath, CancellationToken ct = default)
+	{
+		GitResult result = await GitCli.RunInAsync(repoPath, ct, "pull").ConfigureAwait(false);
+		return result.Succeeded;
+	}
 
-	public Task<bool> CommitAsync(string repoPath, string message, CancellationToken ct = default) =>
-		Task.Run(() =>
+	public async Task<bool> CommitAsync(string repoPath, string message, CancellationToken ct = default)
+	{
+		GitResult staged = await GitCli.RunInAsync(repoPath, ct, "add", "--all").ConfigureAwait(false);
+		if (!staged.Succeeded)
 		{
-			try
-			{
-				using Repository repo = new(repoPath);
-				Commands.Stage(repo, "*");
-				Signature signature = repo.Config.BuildSignature(DateTimeOffset.Now);
-				repo.Commit(message, signature, signature);
-				return true;
-			}
-			catch (LibGit2SharpException)
-			{
-				return false;
-			}
-		}, ct);
+			return false;
+		}
 
-	public Task<bool> PushAsync(string repoPath, CancellationToken ct = default) =>
-		Task.Run(() =>
-		{
-			try
-			{
-				using Repository repo = new(repoPath);
-				Remote? remote = repo.Network.Remotes["origin"];
-				if (remote is null)
-				{
-					return false;
-				}
+		// git exits non-zero when there is nothing staged, which matches the previous behaviour of
+		// reporting failure for an empty commit.
+		GitResult committed = await GitCli.RunInAsync(repoPath, ct, "commit", "-m", message).ConfigureAwait(false);
+		return committed.Succeeded;
+	}
 
-				Branch branch = repo.Head;
-				repo.Network.Push(remote, branch.CanonicalName, new PushOptions());
-				return true;
-			}
-			catch (LibGit2SharpException)
-			{
-				return false;
-			}
-		}, ct);
+	public async Task<bool> PushAsync(string repoPath, CancellationToken ct = default)
+	{
+		// HEAD rather than a branch name so a detached head fails loudly instead of pushing the
+		// wrong ref, and origin explicitly because that is the remote the previous version used.
+		GitResult result = await GitCli.RunInAsync(repoPath, ct, "push", "origin", "HEAD").ConfigureAwait(false);
+		return result.Succeeded;
+	}
 
-	public Task<IReadOnlyList<string>> GetStatusAsync(string repoPath, CancellationToken ct = default) =>
-		Task.Run<IReadOnlyList<string>>(() =>
+	public async Task<IReadOnlyList<string>> GetStatusAsync(string repoPath, CancellationToken ct = default)
+	{
+		GitResult result = await GitCli.RunInAsync(repoPath, ct, "status", "--porcelain").ConfigureAwait(false);
+		if (!result.Succeeded)
 		{
-			try
-			{
-				using Repository repo = new(repoPath);
-				return [.. repo.RetrieveStatus().Select(e => $"{e.State}: {e.FilePath}")];
-			}
-			catch (LibGit2SharpException)
-			{
-				return [];
-			}
-		}, ct);
+			return [];
+		}
 
-	public Task<string> GetCurrentBranchAsync(string repoPath, CancellationToken ct = default) =>
-		Task.Run(() =>
+		List<string> entries = [];
+		foreach (string line in result.OutputLines)
 		{
-			try
+			// Porcelain v1 is a two character status code, a space, then the path.
+			if (line.Length > 3)
 			{
-				using Repository repo = new(repoPath);
-				return repo.Head.FriendlyName;
+				entries.Add($"{line[..2].Trim()}: {line[3..]}");
 			}
-			catch (LibGit2SharpException)
-			{
-				return string.Empty;
-			}
-		}, ct);
+		}
+
+		return entries;
+	}
 
-	public Task<bool> CloneAsync(Uri url, string targetPath, CancellationToken ct = default) =>
-		Task.Run(() =>
+	public async Task<string> GetCurrentBranchAsync(string repoPath, CancellationToken ct = default)
+	{
+		GitResult result = await GitCli.RunInAsync(repoPath, ct, "rev-parse", "--abbrev-ref", "HEAD").ConfigureAwait(false);
+		return result.Succeeded ? result.OutputText : string.Empty;
+	}
+
+	public async Task<bool> CloneAsync(Uri url, string targetPath, CancellationToken ct = default)
+	{
+		Ensure.NotNull(url);
+
+		GitResult result = await GitCli.RunAsync(["clone", url.AbsoluteUri, targetPath], ct).ConfigureAwait(false);
+		return result.Succeeded;
+	}
+
+	public async Task<bool> IsRepositoryAsync(string path, CancellationToken ct = default)
+	{
+		if (!Directory.Exists(path))
 		{
-			try
-			{
-				Repository.Clone(url.AbsoluteUri, targetPath);
-				return true;
-			}
-			catch (LibGit2SharpException)
-			{
-				return false;
-			}
-		}, ct);
+			return false;
+		}
 
-	public Task<bool> IsRepositoryAsync(string path, CancellationToken ct = default) =>
-		Task.Run(() => Repository.IsValid(path), ct);
+		GitResult result = await GitCli.RunInAsync(path, ct, "rev-parse", "--is-inside-work-tree").ConfigureAwait(false);
+		return result.Succeeded && result.OutputText.Equals("true", StringComparison.OrdinalIgnoreCase);
+	}
 }
diff --git a/KtsuTools.Sync/KtsuTools.Sync.csproj b/KtsuTools.Sync/KtsuTools.Sync.csproj
index e7fc1d9..6af62fe 100644
--- a/KtsuTools.Sync/KtsuTools.Sync.csproj
+++ b/KtsuTools.Sync/KtsuTools.Sync.csproj
@@ -11,7 +11,6 @@
     <PackageReference Include="Spectre.Console" />
     <PackageReference Include="Spectre.Console.Ansi" />
     <PackageReference Include="ktsu.Extensions" />
-    <PackageReference Include="LibGit2Sharp" />
     <PackageReference Include="ktsu.Semantics.Paths" />
     <PackageReference Include="ktsu.Semantics.Strings" />
   </ItemGroup>
diff --git a/KtsuTools.Sync/SyncService.cs b/KtsuTools.Sync/SyncService.cs
index 7c2c0d0..242be8f 100644
--- a/KtsuTools.Sync/SyncService.cs
+++ b/KtsuTools.Sync/SyncService.cs
@@ -18,22 +18,16 @@ namespace KtsuTools.Sync;
 using ktsu.Extensions;
 using ktsu.Semantics.Paths;
 
-using KtsuTools.Core.Services.Process;
-
-using LibGit2Sharp;
+using KtsuTools.Core.Services.Git;
 
 using Spectre.Console;
 
 /// <summary>
 /// Service that synchronizes file contents across multiple repositories.
 /// </summary>
-public class SyncService(IProcessService processService)
+public static class SyncService
 {
-	private readonly IProcessService processService = processService;
-
 	private const string CommitAuthorName = "KtsuTools";
-	private const string GitDirSuffixWindows = ".git\\";
-	private const string GitDirSuffixUnix = ".git/";
 
 	/// <summary>
 	/// Runs the sync operation for the specified path and filename.
@@ -42,7 +36,7 @@ public class SyncService(IProcessService processService)
 	/// <param name="filename">The filename pattern to scan for.</param>
 	/// <param name="ct">Cancellation token.</param>
 	/// <returns>Exit code (0 for success).</returns>
-	public Task<int> RunAsync(AbsoluteDirectoryPath path, string filename, CancellationToken ct = default) =>
+	public static Task<int> RunAsync(AbsoluteDirectoryPath path, string filename, CancellationToken ct = default) =>
 		RunAsync(path, [filename], autoPush: false, ct);
 
 	/// <summary>
@@ -53,7 +47,7 @@ public Task<int> RunAsync(AbsoluteDirectoryPath path, string filename, Cancellat
 	/// <param name="autoPush">When true, repos whose unpushed commits are all authored by KtsuTools are pushed without prompting.</param>
 	/// <param name="ct">Cancellation token.</param>
 	/// <returns>Exit code (0 for success).</returns>
-	public async Task<int> RunAsync(AbsoluteDirectoryPath path, IReadOnlyList<string> filenames, bool autoPush, CancellationToken ct = default)
+	public static async Task<int> RunAsync(AbsoluteDirectoryPath path, IReadOnlyList<string> filenames, bool autoPush, CancellationToken ct = default)
 	{
 		Ensure.NotNull(path);
 		ct.ThrowIfCancellationRequested();
@@ -284,15 +278,6 @@ private static async Task SyncFilesToHashAsync(
 		}
 	}
 
-	private static bool IsGitRepoPath(string repoPath) =>
-		repoPath.EndsWith(GitDirSuffixWindows, StringComparison.Ordinal)
-		|| repoPath.EndsWith(GitDirSuffixUnix, StringComparison.Ordinal);
-
-	private static string StripGitSuffix(string repoPath) =>
-		repoPath
-			.Replace(GitDirSuffixWindows, "", StringComparison.Ordinal)
-			.Replace(GitDirSuffixUnix, "", StringComparison.Ordinal);
-
 	private static async Task CommitChangedFilesAsync(
 		HashSet<string> commitDirectories,
 		HashSet<string> expandedFilesToSync,
@@ -300,7 +285,7 @@ private static async Task CommitChangedFilesAsync(
 	{
 		AnsiConsole.WriteLine();
 
-		Collection<string> commitFiles = FindChangedFiles(commitDirectories, expandedFilesToSync, path);
+		Collection<string> commitFiles = await FindChangedFilesAsync(commitDirectories, expandedFilesToSync, path).ConfigureAwait(false);
 
 		if (commitFiles.Count > 0)
 		{
@@ -312,13 +297,13 @@ private static async Task CommitChangedFilesAsync(
 				AnsiConsole.WriteLine();
 				foreach (string filePath in commitFiles)
 				{
-					CommitFile(filePath);
+					await CommitFileAsync(filePath).ConfigureAwait(false);
 				}
 			}
 		}
 	}
 
-	private static Collection<string> FindChangedFiles(
+	private static async Task<Collection<string>> FindChangedFilesAsync(
 		HashSet<string> commitDirectories,
 		HashSet<string> expandedFilesToSync,
 		string path)
@@ -328,18 +313,23 @@ private static Collection<string> FindChangedFiles(
 		foreach (string dir in commitDirectories)
 		{
 			string directoryPath = Path.Combine(path, dir);
-			string repoPath = Repository.Discover(directoryPath);
-			if (repoPath is null || !IsGitRepoPath(repoPath))
+			string repoRoot = await GitCli.DiscoverRootAsync(directoryPath).ConfigureAwait(false);
+			if (string.IsNullOrEmpty(repoRoot))
 			{
 				continue;
 			}
 
-			using Repository repo = new(repoPath);
 			foreach (string uniqueFilename in expandedFilesToSync)
 			{
 				string filePath = Path.Combine(directoryPath, uniqueFilename);
-				FileStatus fileStatus = repo.RetrieveStatus(filePath);
-				if (fileStatus is FileStatus.ModifiedInWorkdir or FileStatus.NewInWorkdir)
+
+				// --porcelain prints nothing for a path that matches HEAD, so any output at all
+				// means the file is either modified or untracked.
+				GitResult status = await GitCli
+					.RunInAsync(repoRoot, CancellationToken.None, "status", "--porcelain", "--", filePath)
+					.ConfigureAwait(false);
+
+				if (status.Succeeded && status.OutputText.Length > 0)
 				{
 					commitFiles.Add(filePath);
 					AnsiConsole.MarkupLine($"[yellow]{filePath.EscapeMarkup()}[/] has outstanding changes");
@@ -350,38 +340,63 @@ private static Collection<string> FindChangedFiles(
 		return commitFiles;
 	}
 
-	private static void CommitFile(string filePath)
+	private static async Task CommitFileAsync(string filePath)
 	{
 		AnsiConsole.MarkupLine($"[green]Committing:[/] {filePath.EscapeMarkup()}");
-		string repoPath = Repository.Discover(filePath);
-		if (string.IsNullOrEmpty(repoPath))
+
+		string repoRoot = await GitCli.DiscoverRootAsync(filePath).ConfigureAwait(false);
+		if (string.IsNullOrEmpty(repoRoot))
 		{
 			return;
 		}
 
-		using Repository repo = new(repoPath);
-		string repoRoot = StripGitSuffix(repoPath);
-		string relativeFilePath = filePath.Replace(repoRoot, "", StringComparison.Ordinal);
-		repo.Index.Add(relativeFilePath);
-		repo.Index.Write();
-		try
-		{
-			Signature signature = new(CommitAuthorName, CommitAuthorName, DateTimeOffset.Now);
-			_ = repo.Commit($"Sync {relativeFilePath}", signature, signature);
-		}
-		catch (EmptyCommitException)
+		// Staging through git, rather than writing the index directly, is what lets the clean
+		// filter run. Without it a file covered by an LFS pattern is committed as raw bytes
+		// instead of a pointer, which is how binary assets ended up in history unmanaged.
+		GitResult staged = await GitCli
+			.RunInAsync(repoRoot, CancellationToken.None, "add", "--", filePath)
+			.ConfigureAwait(false);
+
+		if (!staged.Succeeded)
 		{
-			// No changes to commit
+			AnsiConsole.MarkupLine($"[red]Failed to stage:[/] {filePath.EscapeMarkup()}");
+			AnsiConsole.MarkupLine($"[red]{staged.FailureText.EscapeMarkup()}[/]");
+			return;
 		}
-		catch (UnmergedIndexEntriesException)
+
+		string relativeFilePath = Path.GetRelativePath(repoRoot, filePath);
+
+		// The identity is supplied per invocation so the commit is attributed to the tool without
+		// depending on, or disturbing, whatever the repository has configured.
+		GitResult committed = await GitCli
+			.RunInAsync(
+				repoRoot,
+				CancellationToken.None,
+				"-c", $"user.name={CommitAuthorName}",
+				"-c", $"user.email={CommitAuthorName}",
+				"commit",
+				"-m", $"Sync {relativeFilePath}",
+				"--", filePath)
+			.ConfigureAwait(false);
+
+		if (!committed.Succeeded && !IsNothingToCommit(committed))
 		{
-			AnsiConsole.MarkupLine($"[red]Unmerged entries in:[/] {filePath.EscapeMarkup()}");
+			AnsiConsole.MarkupLine($"[red]Failed to commit:[/] {filePath.EscapeMarkup()}");
+			AnsiConsole.MarkupLine($"[red]{committed.FailureText.EscapeMarkup()}[/]");
 		}
 	}
 
-	private async Task PushToRemoteAsync(HashSet<string> commitDirectories, string path, bool autoPush, CancellationToken ct)
+	/// <summary>
+	/// Distinguishes the ordinary case of the file already matching HEAD, which git reports with a
+	/// non-zero exit code, from a genuine commit failure.
+	/// </summary>
+	private static bool IsNothingToCommit(GitResult result) =>
+		result.Output.Contains("nothing to commit", StringComparison.OrdinalIgnoreCase)
+		|| result.Output.Contains("nothing added to commit", StringComparison.OrdinalIgnoreCase);
+
+	private static async Task PushToRemoteAsync(HashSet<string> commitDirectories, string path, bool autoPush, CancellationToken ct)
 	{
-		Collection<string> pushDirectories = FindPushableDirectories(commitDirectories, path);
+		Collection<string> pushDirectories = await FindPushableDirectoriesAsync(commitDirectories, path).ConfigureAwait(false);
 
 		if (pushDirectories.Count == 0)
 		{
@@ -413,26 +428,41 @@ private async Task PushToRemoteAsync(HashSet<string> commitDirectories, string p
 		}
 	}
 
-	private static Collection<string> FindPushableDirectories(HashSet<string> commitDirectories, string path)
+	private static async Task<Collection<string>> FindPushableDirectoriesAsync(HashSet<string> commitDirectories, string path)
 	{
 		Collection<string> pushDirectories = [];
-		IEnumerable<string> commitRepos = commitDirectories
-			.Select(f => Repository.Discover(Path.Combine(path, f)))
-			.Where(r => !string.IsNullOrEmpty(r) && IsGitRepoPath(r))
-			.Distinct();
+		HashSet<string> seenRoots = [];
 
-		foreach (string repoPath in commitRepos)
+		foreach (string dir in commitDirectories)
 		{
-			using Repository repo = new(repoPath);
-			string repoRoot = StripGitSuffix(repoPath);
-			Branch localBranch = repo.Branches[repo.Head.FriendlyName];
-			int aheadBy = localBranch?.TrackingDetails.AheadBy ?? 0;
+			string repoRoot = await GitCli.DiscoverRootAsync(Path.Combine(path, dir)).ConfigureAwait(false);
+			if (string.IsNullOrEmpty(repoRoot) || !seenRoots.Add(repoRoot))
+			{
+				continue;
+			}
+
+			// @{u} is the configured upstream. Without one, rev-list fails and there is nothing
+			// meaningful to push, so treat that as zero commits ahead.
+			GitResult ahead = await GitCli
+				.RunInAsync(repoRoot, CancellationToken.None, "rev-list", "--count", "@{u}..HEAD")
+				.ConfigureAwait(false);
+
+			if (!ahead.Succeeded || !int.TryParse(ahead.OutputText, out int aheadBy) || aheadBy == 0)
+			{
+				continue;
+			}
+
+			// Only push when every unpushed commit is one this tool made, so a user's own work is
+			// never pushed on their behalf.
+			GitResult authors = await GitCli
+				.RunInAsync(repoRoot, CancellationToken.None, "log", "--format=%an", $"-{aheadBy}", "HEAD")
+				.ConfigureAwait(false);
 
-			bool canPush = repo.Head.Commits
-				.Take(aheadBy)
-				.All(commit => commit.Author.Name == CommitAuthorName);
+			bool canPush = authors.Succeeded
+				&& authors.OutputLines.Count == aheadBy
+				&& authors.OutputLines.All(author => author == CommitAuthorName);
 
-			if (aheadBy > 0 && canPush)
+			if (canPush)
 			{
 				pushDirectories.Add(repoRoot);
 				AnsiConsole.MarkupLine($"[cyan]{repoRoot.EscapeMarkup()}[/] can be pushed automatically");
@@ -442,30 +472,30 @@ private static Collection<string> FindPushableDirectories(HashSet<string> commit
 		return pushDirectories;
 	}
 
-	private async Task PushDirectoryAsync(string repoRoot, CancellationToken ct)
+	private static async Task PushDirectoryAsync(string repoRoot, CancellationToken ct)
 	{
 		AnsiConsole.MarkupLine($"[green]Pushing:[/] {repoRoot.EscapeMarkup()}");
 
 		AnsiConsole.MarkupLine("[dim]Pulling remote changes...[/]");
-		ProcessResult pull = await processService.RunAsync("git", "pull", repoRoot, ct).ConfigureAwait(false);
-		if (pull.ExitCode != 0)
+		GitResult pull = await GitCli.RunInAsync(repoRoot, ct, "pull").ConfigureAwait(false);
+		if (!pull.Succeeded)
 		{
-			string pullMessage = pull.Errors.Count > 0 ? string.Join('\n', pull.Errors) : string.Join('\n', pull.Output);
 			AnsiConsole.MarkupLine($"[red]Pull failed for:[/] {repoRoot.EscapeMarkup()}");
-			AnsiConsole.MarkupLine($"[red]{pullMessage.EscapeMarkup()}[/]");
+			AnsiConsole.MarkupLine($"[red]{pull.FailureText.EscapeMarkup()}[/]");
 			AnsiConsole.MarkupLine("[yellow]Skipping push to avoid non-fast-forward; resolve conflicts manually.[/]");
 			return;
 		}
 
-		ProcessResult push = await processService.RunAsync("git", "push", repoRoot, ct).ConfigureAwait(false);
-		if (push.ExitCode == 0)
+		// Pushing through git runs the LFS pre-push hook, which is what uploads the objects that
+		// the committed pointers refer to. A library push would leave those pointers dangling.
+		GitResult push = await GitCli.RunInAsync(repoRoot, ct, "push").ConfigureAwait(false);
+		if (push.Succeeded)
 		{
 			AnsiConsole.MarkupLine($"[green]Successfully pushed:[/] {repoRoot.EscapeMarkup()}");
 		}
 		else
 		{
-			string pushMessage = push.Errors.Count > 0 ? string.Join('\n', push.Errors) : string.Join('\n', push.Output);
-			AnsiConsole.MarkupLine($"[red]Error pushing:[/] {pushMessage.EscapeMarkup()}");
+			AnsiConsole.MarkupLine($"[red]Error pushing:[/] {push.FailureText.EscapeMarkup()}");
 		}
 	}
 
diff --git a/KtsuTools.Test/SmokeTests.cs b/KtsuTools.Test/SmokeTests.cs
index 087203c..f0bc70e 100644
--- a/KtsuTools.Test/SmokeTests.cs
+++ b/KtsuTools.Test/SmokeTests.cs
@@ -41,6 +41,6 @@ public void FeatureServicesCanBeCreated()
 		Assert.IsNotNull(new Project.ProjectService(mockGitService, mockGitHubService));
 		Assert.IsNotNull(new FileExplorer.FileExplorerService());
 		Assert.IsNotNull(new SvnMigrate.SvnMigrateService(mockProcessService));
-		Assert.IsNotNull(new Sync.SyncService(mockProcessService));
+		Assert.IsNotNull(typeof(Sync.SyncService));
 	}
 }
diff --git a/KtsuTools/Commands/SyncCommand.cs b/KtsuTools/Commands/SyncCommand.cs
index ba92a1b..9afd480 100644
--- a/KtsuTools/Commands/SyncCommand.cs
+++ b/KtsuTools/Commands/SyncCommand.cs
@@ -20,9 +20,8 @@ namespace KtsuTools.Commands;
 /// <summary>
 /// Command that synchronizes file contents across repositories.
 /// </summary>
-public sealed class SyncCommand(SyncService syncService) : AsyncCommand<SyncCommand.Settings>
+public sealed class SyncCommand : AsyncCommand<SyncCommand.Settings>
 {
-	private readonly SyncService syncService = syncService;
 
 	/// <summary>
 	/// Settings for the sync command.
@@ -71,7 +70,7 @@ protected override async Task<int> ExecuteAsync(CommandContext context, Settings
 
 		using CtrlCScope scope = new();
 		AbsoluteDirectoryPath rootPath = AbsoluteDirectoryPath.Create<AbsoluteDirectoryPath>(Path.GetFullPath(path));
-		return await syncService.RunAsync(rootPath, filenames, settings.AutoPush, scope.Token).ConfigureAwait(false);
+		return await SyncService.RunAsync(rootPath, filenames, settings.AutoPush, scope.Token).ConfigureAwait(false);
 	}
 
 	private static List<string> ExpandFilenames(IEnumerable<string> raw) =>
diff --git a/KtsuTools/Program.cs b/KtsuTools/Program.cs
index 205cf3b..871b78a 100644
--- a/KtsuTools/Program.cs
+++ b/KtsuTools/Program.cs
@@ -19,7 +19,6 @@ namespace KtsuTools;
 using KtsuTools.Project;
 using KtsuTools.Repo;
 using KtsuTools.SvnMigrate;
-using KtsuTools.Sync;
 using Microsoft.Extensions.DependencyInjection;
 using Spectre.Console.Cli;
 
@@ -44,7 +43,6 @@ private static int Main(string[] args)
 		services.AddSingleton<MemFragService>();
 		services.AddSingleton<MachineMonitorService>();
 		services.AddSingleton<ProjectService>();
-		services.AddSingleton<SyncService>();
 		services.AddSingleton<FileDedupeService>();
 
 		TypeRegistrar registrar = new(services);
diff --git a/global.json b/global.json
index 01ae7ef..39f7683 100644
--- a/global.json
+++ b/global.json
@@ -5,15 +5,15 @@
   },
   "msbuild-sdks": {
     "MSTest.Sdk": "4.3.3",
-    "ktsu.Sdk": "2.17.1",
-    "ktsu.Sdk.ConsoleApp": "2.17.1",
-    "ktsu.Sdk.Tool": "2.17.1",
-    "ktsu.Sdk.App": "2.17.1",
-    "ktsu.Sdk.Windows": "2.17.1",
-    "ktsu.Sdk.Linux": "2.17.1",
-    "ktsu.Sdk.macOS": "2.17.1",
-    "ktsu.Sdk.iOS": "2.17.1",
-    "ktsu.Sdk.Android": "2.17.1"
+    "ktsu.Sdk": "2.21.1",
+    "ktsu.Sdk.ConsoleApp": "2.21.1",
+    "ktsu.Sdk.Tool": "2.21.1",
+    "ktsu.Sdk.App": "2.21.1",
+    "ktsu.Sdk.Windows": "2.21.1",
+    "ktsu.Sdk.Linux": "2.21.1",
+    "ktsu.Sdk.macOS": "2.21.1",
+    "ktsu.Sdk.iOS": "2.21.1",
+    "ktsu.Sdk.Android": "2.21.1"
   },
   "test": {
     "runner": "Microsoft.Testing.Platform"