Refactor git core into pluggable VCS driver

- Move low-level git service into `GitVcsDriverCore` - Update server wiring and tests to use the new driver

Julius Marminge committed 6 months ago

Commit a11d6b91 parent 82a83945 files · +929 −904Browse files

Unified · Split

5 files

apps/server/src/git/Layers/GitManager.ts +1 −2
apps/server/src/git/Services/GitCore.ts +0 −288
apps/server/src/vcs/GitVcsDriver.ts +185 −6
apps/server/src/vcs/GitVcsDriverCore.test.ts +378 −255
apps/server/src/vcs/GitVcsDriverCore.ts +365 −353

apps/server/src/git/Layers/GitManager.ts+1−2

   type GitManagerShape,
   type GitRunStackedActionOptions,
 } from "../Services/GitManager.ts";
-import type { GitStatusDetails } from "../Services/GitCore.ts";
 import { GitHubCli, type GitHubPullRequestSummary } from "../Services/GitHubCli.ts";
 import { TextGeneration } from "../Services/TextGeneration.ts";
 import { ProjectSetupScriptRunner } from "../../project/Services/ProjectSetupScriptRunner.ts";
   decodeGitHubPullRequestListJson,
   formatGitHubJsonDecodeError,
 } from "../githubPullRequests.ts";
-import { GitVcsDriver } from "../../vcs/GitVcsDriver.ts";
+import { GitVcsDriver, type GitStatusDetails } from "../../vcs/GitVcsDriver.ts";
 const COMMIT_TIMEOUT_MS = 10 * 60_000;
 const MAX_PROGRESS_TEXT_LENGTH = 500;

apps/server/src/git/Services/GitCore.ts+0−288

@@ -1,288 +0,0 @@
1	/**
2	* GitCore - Effect service contract for low-level Git operations.
3	*
4	* Wraps core repository primitives used by higher-level orchestration
5	* services and WebSocket routes.
6	*
7	* @module GitCore
8	*/
9	import { Context } from "effect";
10	import type { Effect } from "effect";
11	import type {
12	GitCheckoutInput,
13	GitCheckoutResult,
14	GitCreateBranchInput,
15	GitCreateBranchResult,
16	GitCreateWorktreeInput,
17	GitCreateWorktreeResult,
18	GitInitInput,
19	GitListBranchesInput,
20	GitListBranchesResult,
21	GitPullResult,
22	GitRemoveWorktreeInput,
23	GitStatusInput,
24	GitStatusResult,
25	} from "@t3tools/contracts";
26
27	import type { GitCommandError } from "@t3tools/contracts";
28
29	export interface ExecuteGitInput {
30	readonly operation: string;
31	readonly cwd: string;
32	readonly args: ReadonlyArray<string>;
33	readonly stdin?: string;
34	readonly env?: NodeJS.ProcessEnv;
35	readonly allowNonZeroExit?: boolean;
36	readonly timeoutMs?: number;
37	readonly maxOutputBytes?: number;
38	readonly truncateOutputAtMaxBytes?: boolean;
39	readonly progress?: ExecuteGitProgress;
40	}
41
42	export interface ExecuteGitResult {
43	readonly code: number;
44	readonly stdout: string;
45	readonly stderr: string;
46	readonly stdoutTruncated: boolean;
47	readonly stderrTruncated: boolean;
48	}
49
50	export interface GitStatusDetails extends Omit<GitStatusResult, "pr"> {
51	upstreamRef: string \| null;
52	}
53
54	export interface GitPreparedCommitContext {
55	stagedSummary: string;
56	stagedPatch: string;
57	}
58
59	export interface ExecuteGitProgress {
60	readonly onStdoutLine?: (line: string) => Effect.Effect<void, never>;
61	readonly onStderrLine?: (line: string) => Effect.Effect<void, never>;
62	readonly onHookStarted?: (hookName: string) => Effect.Effect<void, never>;
63	readonly onHookFinished?: (input: {
64	hookName: string;
65	exitCode: number \| null;
66	durationMs: number \| null;
67	}) => Effect.Effect<void, never>;
68	}
69
70	export interface GitCommitProgress {
71	readonly onOutputLine?: (input: {
72	stream: "stdout" \| "stderr";
73	text: string;
74	}) => Effect.Effect<void, never>;
75	readonly onHookStarted?: (hookName: string) => Effect.Effect<void, never>;
76	readonly onHookFinished?: (input: {
77	hookName: string;
78	exitCode: number \| null;
79	durationMs: number \| null;
80	}) => Effect.Effect<void, never>;
81	}
82
83	export interface GitCommitOptions {
84	readonly timeoutMs?: number;
85	readonly progress?: GitCommitProgress;
86	}
87
88	export interface GitPushResult {
89	status: "pushed" \| "skipped_up_to_date";
90	branch: string;
91	upstreamBranch?: string \| undefined;
92	setUpstream?: boolean \| undefined;
93	}
94
95	export interface GitRangeContext {
96	commitSummary: string;
97	diffSummary: string;
98	diffPatch: string;
99	}
100
101	export interface GitRenameBranchInput {
102	cwd: string;
103	oldBranch: string;
104	newBranch: string;
105	}
106
107	export interface GitRenameBranchResult {
108	branch: string;
109	}
110
111	export interface GitFetchPullRequestBranchInput {
112	cwd: string;
113	prNumber: number;
114	branch: string;
115	}
116
117	export interface GitEnsureRemoteInput {
118	cwd: string;
119	preferredName: string;
120	url: string;
121	}
122
123	export interface GitFetchRemoteBranchInput {
124	cwd: string;
125	remoteName: string;
126	remoteBranch: string;
127	localBranch: string;
128	}
129
130	export interface GitSetBranchUpstreamInput {
131	cwd: string;
132	branch: string;
133	remoteName: string;
134	remoteBranch: string;
135	}
136
137	/**
138	* GitCoreShape - Service API for low-level Git repository interactions.
139	*/
140	export interface GitCoreShape {
141	/**
142	* Execute a raw Git command.
143	*/
144	readonly execute: (input: ExecuteGitInput) => Effect.Effect<ExecuteGitResult, GitCommandError>;
145
146	/**
147	* Read Git status for a repository.
148	*/
149	readonly status: (input: GitStatusInput) => Effect.Effect<GitStatusResult, GitCommandError>;
150
151	/**
152	* Read detailed working tree / branch status for a repository.
153	*/
154	readonly statusDetails: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
155
156	/**
157	* Read detailed working tree / branch status without refreshing remote tracking refs.
158	*/
159	readonly statusDetailsLocal: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
160
161	/**
162	* Build staged change context for commit generation.
163	*/
164	readonly prepareCommitContext: (
165	cwd: string,
166	filePaths?: readonly string[],
167	) => Effect.Effect<GitPreparedCommitContext \| null, GitCommandError>;
168
169	/**
170	* Create a commit with provided subject/body.
171	*/
172	readonly commit: (
173	cwd: string,
174	subject: string,
175	body: string,
176	options?: GitCommitOptions,
177	) => Effect.Effect<{ commitSha: string }, GitCommandError>;
178
179	/**
180	* Push current branch, setting upstream if needed.
181	*/
182	readonly pushCurrentBranch: (
183	cwd: string,
184	fallbackBranch: string \| null,
185	) => Effect.Effect<GitPushResult, GitCommandError>;
186
187	/**
188	* Collect commit/diff context between base branch and current HEAD.
189	*/
190	readonly readRangeContext: (
191	cwd: string,
192	baseBranch: string,
193	) => Effect.Effect<GitRangeContext, GitCommandError>;
194
195	/**
196	* Read a Git config value from the local repository.
197	*/
198	readonly readConfigValue: (
199	cwd: string,
200	key: string,
201	) => Effect.Effect<string \| null, GitCommandError>;
202
203	/**
204	* List local + remote branches and branch metadata.
205	*/
206	readonly listBranches: (
207	input: GitListBranchesInput,
208	) => Effect.Effect<GitListBranchesResult, GitCommandError>;
209
210	/**
211	* Pull current branch from upstream using fast-forward only.
212	*/
213	readonly pullCurrentBranch: (cwd: string) => Effect.Effect<GitPullResult, GitCommandError>;
214
215	/**
216	* Create a worktree and branch from a base branch.
217	*/
218	readonly createWorktree: (
219	input: GitCreateWorktreeInput,
220	) => Effect.Effect<GitCreateWorktreeResult, GitCommandError>;
221
222	/**
223	* Materialize a GitHub pull request head as a local branch without switching checkout.
224	*/
225	readonly fetchPullRequestBranch: (
226	input: GitFetchPullRequestBranchInput,
227	) => Effect.Effect<void, GitCommandError>;
228
229	/**
230	* Ensure a named remote exists for the provided URL, returning the reused or created remote name.
231	*/
232	readonly ensureRemote: (input: GitEnsureRemoteInput) => Effect.Effect<string, GitCommandError>;
233
234	/**
235	* Fetch a remote branch into a local branch without checkout.
236	*/
237	readonly fetchRemoteBranch: (
238	input: GitFetchRemoteBranchInput,
239	) => Effect.Effect<void, GitCommandError>;
240
241	/**
242	* Set the upstream tracking branch for a local branch.
243	*/
244	readonly setBranchUpstream: (
245	input: GitSetBranchUpstreamInput,
246	) => Effect.Effect<void, GitCommandError>;
247
248	/**
249	* Remove an existing worktree.
250	*/
251	readonly removeWorktree: (input: GitRemoveWorktreeInput) => Effect.Effect<void, GitCommandError>;
252
253	/**
254	* Rename an existing local branch.
255	*/
256	readonly renameBranch: (
257	input: GitRenameBranchInput,
258	) => Effect.Effect<GitRenameBranchResult, GitCommandError>;
259
260	/**
261	* Create a local branch.
262	*/
263	readonly createBranch: (
264	input: GitCreateBranchInput,
265	) => Effect.Effect<GitCreateBranchResult, GitCommandError>;
266
267	/**
268	* Checkout an existing branch and refresh its upstream metadata in background.
269	*/
270	readonly checkoutBranch: (
271	input: GitCheckoutInput,
272	) => Effect.Effect<GitCheckoutResult, GitCommandError>;
273
274	/**
275	* Initialize a repository in the provided directory.
276	*/
277	readonly initRepo: (input: GitInitInput) => Effect.Effect<void, GitCommandError>;
278
279	/**
280	* List local branch names (short format).
281	*/
282	readonly listLocalBranchNames: (cwd: string) => Effect.Effect<string[], GitCommandError>;
283	}
284
285	/**
286	* GitCore - Service tag for low-level Git repository operations.
287	*/
288	export class GitCore extends Context.Service<GitCore, GitCoreShape>()("t3/git/Services/GitCore") {}

apps/server/src/vcs/GitVcsDriver.ts+185−6

@@ -1,12 +1,191 @@
1	import { Context, DateTime, Effect, Layer } from "effect";	1	import { Context, DateTime, Effect, Layer } from "effect";
2		2
3	import { VcsProcessExitError } from "@t3tools/contracts";	3	import {
4	import { makeGitCore } from "../git/Layers/GitCore.ts";	4	GitCommandError,
5	import type { GitCoreShape } from "../git/Services/GitCore.ts";	5	VcsProcessExitError,
		6	type GitCheckoutInput,
		7	type GitCheckoutResult,
		8	type GitCreateBranchInput,
		9	type GitCreateBranchResult,
		10	type GitCreateWorktreeInput,
		11	type GitCreateWorktreeResult,
		12	type GitInitInput,
		13	type GitListBranchesInput,
		14	type GitListBranchesResult,
		15	type GitPullResult,
		16	type GitRemoveWorktreeInput,
		17	type GitStatusInput,
		18	type GitStatusResult,
		19	} from "@t3tools/contracts";
		20	import { makeGitVcsDriverCore } from "./GitVcsDriverCore.ts";
6	import { VcsDriver, type VcsDriverShape } from "./VcsDriver.ts";	21	import { VcsDriver, type VcsDriverShape } from "./VcsDriver.ts";
7	import { VcsProcess, type VcsProcessShape } from "./VcsProcess.ts";	22	import { VcsProcess, type VcsProcessShape } from "./VcsProcess.ts";
8		23
9	export interface GitVcsDriverShape extends GitCoreShape {}	24	export interface ExecuteGitInput {
		25	readonly operation: string;
		26	readonly cwd: string;
		27	readonly args: ReadonlyArray<string>;
		28	readonly stdin?: string;
		29	readonly env?: NodeJS.ProcessEnv;
		30	readonly allowNonZeroExit?: boolean;
		31	readonly timeoutMs?: number;
		32	readonly maxOutputBytes?: number;
		33	readonly truncateOutputAtMaxBytes?: boolean;
		34	readonly progress?: ExecuteGitProgress;
		35	}
		36
		37	export interface ExecuteGitResult {
		38	readonly code: number;
		39	readonly stdout: string;
		40	readonly stderr: string;
		41	readonly stdoutTruncated: boolean;
		42	readonly stderrTruncated: boolean;
		43	}
		44
		45	export interface GitStatusDetails extends Omit<GitStatusResult, "pr"> {
		46	upstreamRef: string \| null;
		47	}
		48
		49	export interface GitPreparedCommitContext {
		50	stagedSummary: string;
		51	stagedPatch: string;
		52	}
		53
		54	export interface ExecuteGitProgress {
		55	readonly onStdoutLine?: (line: string) => Effect.Effect<void, never>;
		56	readonly onStderrLine?: (line: string) => Effect.Effect<void, never>;
		57	readonly onHookStarted?: (hookName: string) => Effect.Effect<void, never>;
		58	readonly onHookFinished?: (input: {
		59	hookName: string;
		60	exitCode: number \| null;
		61	durationMs: number \| null;
		62	}) => Effect.Effect<void, never>;
		63	}
		64
		65	export interface GitCommitProgress {
		66	readonly onOutputLine?: (input: {
		67	stream: "stdout" \| "stderr";
		68	text: string;
		69	}) => Effect.Effect<void, never>;
		70	readonly onHookStarted?: (hookName: string) => Effect.Effect<void, never>;
		71	readonly onHookFinished?: (input: {
		72	hookName: string;
		73	exitCode: number \| null;
		74	durationMs: number \| null;
		75	}) => Effect.Effect<void, never>;
		76	}
		77
		78	export interface GitCommitOptions {
		79	readonly timeoutMs?: number;
		80	readonly progress?: GitCommitProgress;
		81	}
		82
		83	export interface GitPushResult {
		84	status: "pushed" \| "skipped_up_to_date";
		85	branch: string;
		86	upstreamBranch?: string \| undefined;
		87	setUpstream?: boolean \| undefined;
		88	}
		89
		90	export interface GitRangeContext {
		91	commitSummary: string;
		92	diffSummary: string;
		93	diffPatch: string;
		94	}
		95
		96	export interface GitRenameBranchInput {
		97	cwd: string;
		98	oldBranch: string;
		99	newBranch: string;
		100	}
		101
		102	export interface GitRenameBranchResult {
		103	branch: string;
		104	}
		105
		106	export interface GitFetchPullRequestBranchInput {
		107	cwd: string;
		108	prNumber: number;
		109	branch: string;
		110	}
		111
		112	export interface GitEnsureRemoteInput {
		113	cwd: string;
		114	preferredName: string;
		115	url: string;
		116	}
		117
		118	export interface GitFetchRemoteBranchInput {
		119	cwd: string;
		120	remoteName: string;
		121	remoteBranch: string;
		122	localBranch: string;
		123	}
		124
		125	export interface GitSetBranchUpstreamInput {
		126	cwd: string;
		127	branch: string;
		128	remoteName: string;
		129	remoteBranch: string;
		130	}
		131
		132	export interface GitVcsDriverShape {
		133	readonly execute: (input: ExecuteGitInput) => Effect.Effect<ExecuteGitResult, GitCommandError>;
		134	readonly status: (input: GitStatusInput) => Effect.Effect<GitStatusResult, GitCommandError>;
		135	readonly statusDetails: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
		136	readonly statusDetailsLocal: (cwd: string) => Effect.Effect<GitStatusDetails, GitCommandError>;
		137	readonly prepareCommitContext: (
		138	cwd: string,
		139	filePaths?: readonly string[],
		140	) => Effect.Effect<GitPreparedCommitContext \| null, GitCommandError>;
		141	readonly commit: (
		142	cwd: string,
		143	subject: string,
		144	body: string,
		145	options?: GitCommitOptions,
		146	) => Effect.Effect<{ commitSha: string }, GitCommandError>;
		147	readonly pushCurrentBranch: (
		148	cwd: string,
		149	fallbackBranch: string \| null,
		150	) => Effect.Effect<GitPushResult, GitCommandError>;
		151	readonly readRangeContext: (
		152	cwd: string,
		153	baseBranch: string,
		154	) => Effect.Effect<GitRangeContext, GitCommandError>;
		155	readonly readConfigValue: (
		156	cwd: string,
		157	key: string,
		158	) => Effect.Effect<string \| null, GitCommandError>;
		159	readonly listBranches: (
		160	input: GitListBranchesInput,
		161	) => Effect.Effect<GitListBranchesResult, GitCommandError>;
		162	readonly pullCurrentBranch: (cwd: string) => Effect.Effect<GitPullResult, GitCommandError>;
		163	readonly createWorktree: (
		164	input: GitCreateWorktreeInput,
		165	) => Effect.Effect<GitCreateWorktreeResult, GitCommandError>;
		166	readonly fetchPullRequestBranch: (
		167	input: GitFetchPullRequestBranchInput,
		168	) => Effect.Effect<void, GitCommandError>;
		169	readonly ensureRemote: (input: GitEnsureRemoteInput) => Effect.Effect<string, GitCommandError>;
		170	readonly fetchRemoteBranch: (
		171	input: GitFetchRemoteBranchInput,
		172	) => Effect.Effect<void, GitCommandError>;
		173	readonly setBranchUpstream: (
		174	input: GitSetBranchUpstreamInput,
		175	) => Effect.Effect<void, GitCommandError>;
		176	readonly removeWorktree: (input: GitRemoveWorktreeInput) => Effect.Effect<void, GitCommandError>;
		177	readonly renameBranch: (
		178	input: GitRenameBranchInput,
		179	) => Effect.Effect<GitRenameBranchResult, GitCommandError>;
		180	readonly createBranch: (
		181	input: GitCreateBranchInput,
		182	) => Effect.Effect<GitCreateBranchResult, GitCommandError>;
		183	readonly checkoutBranch: (
		184	input: GitCheckoutInput,
		185	) => Effect.Effect<GitCheckoutResult, GitCommandError>;
		186	readonly initRepo: (input: GitInitInput) => Effect.Effect<void, GitCommandError>;
		187	readonly listLocalBranchNames: (cwd: string) => Effect.Effect<string[], GitCommandError>;
		188	}
10		189
11	export class GitVcsDriver extends Context.Service<GitVcsDriver, GitVcsDriverShape>()(	190	export class GitVcsDriver extends Context.Service<GitVcsDriver, GitVcsDriverShape>()(
12	"t3/vcs/GitVcsDriver",	191	"t3/vcs/GitVcsDriver",
@@ -259,8 +438,8 @@ export const makeVcsDriver = Effect.fn("makeGitVcsDriver")(function* () { · 246 unmodified lines
259	});	438	});
260		439
261	export const make = Effect.fn("makeGitVcsDriverService")(function* () {	440	export const make = Effect.fn("makeGitVcsDriverService")(function* () {
262	const legacyGit = yield* makeGitCore();	441	const git = yield* makeGitVcsDriverCore();
263	return GitVcsDriver.of(legacyGit);	442	return GitVcsDriver.of(git);
264	});	443	});
265		444
266	export const vcsLayer = Layer.effect(VcsDriver, makeVcsDriver());	445	export const vcsLayer = Layer.effect(VcsDriver, makeVcsDriver());

apps/server/src/vcs/GitVcsDriverCore.test.tsrenamed from apps/server/src/git/Layers/GitCore.test.ts+378−255

 import { Effect, FileSystem, Layer, PlatformError, Scope } from "effect";
 import { describe, expect, vi } from "vitest";
-import { GitCoreLive, makeGitCore } from "./GitCore.ts";
+import { makeGitVcsDriverCore } from "./GitVcsDriverCore.ts";
-import { GitCore, type GitCoreShape } from "../Services/GitCore.ts";
+import * as GitVcsDriver from "./GitVcsDriver.ts";
 import { GitCommandError } from "@t3tools/contracts";
-import { type ProcessRunResult, runProcess } from "../../processRunner.ts";
+import { type ProcessRunResult, runProcess } from "../processRunner.ts";
-import { ServerConfig } from "../../config.ts";
+import { ServerConfig } from "../config.ts";
 // ── Helpers ──
 const ServerConfigLayer = ServerConfig.layerTest(process.cwd(), { prefix: "t3-git-core-test-" });
-const GitCoreTestLayer = GitCoreLive.pipe(
+const GitVcsDriverTestLayer = GitVcsDriver.layer.pipe(
   Layer.provide(ServerConfigLayer),
   Layer.provide(NodeServices.layer),
 );
-const TestLayer = Layer.mergeAll(NodeServices.layer, GitCoreTestLayer);
+const TestLayer = Layer.mergeAll(NodeServices.layer, GitVcsDriverTestLayer);
 function makeTmpDir(
   prefix = "git-test-",
   cwd: string,
   args: ReadonlyArray<string>,
   env?: NodeJS.ProcessEnv,
-): Effect.Effect<string, GitCommandError, GitCore> {
+): Effect.Effect<string, GitCommandError, GitVcsDriver.GitVcsDriver> {
   return Effect.gen(function* () {
-    const gitCore = yield* GitCore;
+    const gitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
-    const result = yield* gitCore.execute({
+    const result = yield* gitVcsDriver.execute({
-      operation: "GitCore.test.git",
+      operation: "GitVcsDriver.test.git",
       cwd,
       args,
       ...(env ? { env } : {}),
   remoteName: string,
   remotePath: string,
   fetchNamespace: string,
-): Effect.Effect<string, GitCommandError, GitCore> {
+): Effect.Effect<string, GitCommandError, GitVcsDriver.GitVcsDriver> {
   return Effect.gen(function* () {
     yield* git(cwd, ["config", `remote.${remoteName}.url`, remotePath]);
     return yield* git(cwd, [
   });
 }
-const makeIsolatedGitCore = (executeOverride: GitCoreShape["execute"]) =>
+const makeIsolatedGitVcsDriver = (executeOverride: GitVcsDriver.GitVcsDriverShape["execute"]) =>
-  makeGitCore({ executeOverride }).pipe(
+  makeGitVcsDriverCore({ executeOverride }).pipe(
     Effect.provide(Layer.provideMerge(ServerConfigLayer, NodeServices.layer)),
   );
 ): Effect.Effect<
   { initialBranch: string },
   GitCommandError | PlatformError.PlatformError,
-  GitCore | FileSystem.FileSystem
+  GitVcsDriver.GitVcsDriver | FileSystem.FileSystem
 > {
   return Effect.gen(function* () {
-    const core = yield* GitCore;
+    const core = yield* GitVcsDriver.GitVcsDriver;
     yield* core.initRepo({ cwd });
     yield* git(cwd, ["config", "user.email", "test@test.com"]);
     yield* git(cwd, ["config", "user.name", "Test"]);
 ): Effect.Effect<
   void,
   GitCommandError | PlatformError.PlatformError,
-  GitCore | FileSystem.FileSystem
+  GitVcsDriver.GitVcsDriver | FileSystem.FileSystem
 > {
   return Effect.gen(function* () {
     yield* writeTextFile(path.join(cwd, fileName), fileContents);
     it.effect("creates a valid git repo", () =>
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
-        yield* (yield* GitCore).initRepo({ cwd: tmp });
+        yield* (yield* GitVcsDriver.GitVcsDriver).initRepo({ cwd: tmp });
         expect(existsSync(path.join(tmp, ".git"))).toBe(true);
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.isRepo).toBe(true);
         expect(result.hasOriginRemote).toBe(false);
         expect(result.branches.length).toBeGreaterThanOrEqual(1);
     it.effect("returns isRepo: false for non-git directory", () =>
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.isRepo).toBe(false);
         expect(result.hasOriginRemote).toBe(false);
         expect(result.branches).toEqual([]);
         yield* makeDirectory(deletedDir);
         yield* removePath(deletedDir);
-        const result = yield* (yield* GitCore).listBranches({ cwd: deletedDir });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: deletedDir });
         expect(result.isRepo).toBe(false);
         expect(result.hasOriginRemote).toBe(false);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const current = result.branches.find((b) => b.current);
         expect(current).toBeDefined();
         expect(current!.current).toBe(true);
         yield* initRepoWithCommit(tmp);
         yield* git(tmp, ["checkout", "--detach", "HEAD"]);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches.some((branch) => branch.name.startsWith("("))).toBe(false);
         expect(result.branches.some((branch) => branch.current)).toBe(false);
       }),
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const initialBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "older-branch" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "older-branch" });
+          cwd: tmp,
+          branch: "older-branch",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "older-branch",
+        });
         yield* commitWithDate(
           tmp,
           "older.txt",
           "older branch change",
         );
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: initialBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "newer-branch" });
+          cwd: tmp,
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "newer-branch" });
+          branch: initialBranch,
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "newer-branch",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "newer-branch",
+        });
         yield* commitWithDate(
           tmp,
           "newer.txt",
         );
         // Switch away to show current branch is pinned, then remaining branches are recency-sorted.
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "older-branch" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "older-branch",
+        });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches[0]!.name).toBe("older-branch");
         expect(result.branches[1]!.name).toBe("newer-branch");
       }),
         const tmp = yield* makeTmpDir();
         const remote = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(remote, ["init", "--bare"]);
         yield* git(tmp, ["remote", "add", "origin", remote]);
         yield* git(tmp, ["push", "-u", "origin", defaultBranch]);
         yield* git(tmp, ["remote", "set-head", "origin", defaultBranch]);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "current-branch" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "current-branch" });
+          cwd: tmp,
+          branch: "current-branch",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "current-branch",
+        });
         yield* commitWithDate(
           tmp,
           "current.txt",
           "current change",
         );
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: defaultBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "newer-branch" });
+          cwd: tmp,
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "newer-branch" });
+          branch: defaultBranch,
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "newer-branch",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "newer-branch",
+        });
         yield* commitWithDate(
           tmp,
           "newer.txt",
           "newer change",
         );
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "current-branch" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "current-branch",
+        });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches[0]!.name).toBe("current-branch");
         expect(result.branches[1]!.name).toBe(defaultBranch);
         expect(result.branches[2]!.name).toBe("newer-branch");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-a" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature-a" });
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-b" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature-b" });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const names = result.branches.map((b) => b.name);
         expect(names).toContain("feature-a");
         expect(names).toContain("feature-b");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         const { initialBranch } = yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-a" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature-a" });
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-b" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature-b" });
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-c" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature-c" });
-        const firstPage = yield* (yield* GitCore).listBranches({ cwd: tmp, limit: 2 });
+        const firstPage = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
+          cwd: tmp,
+          limit: 2,
+        });
         expect(firstPage.totalCount).toBe(4);
         expect(firstPage.nextCursor).toBe(2);
         expect(firstPage.branches.map((branch) => branch.name)).toEqual([
           "feature-a",
         ]);
-        const secondPage = yield* (yield* GitCore).listBranches({
+        const secondPage = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
           cwd: tmp,
           cursor: firstPage.nextCursor ?? 0,
           limit: 2,
           "copilot/rewrite-cli-in-rust",
         ] as const;
         for (const branchName of createdBranchNames) {
-          yield* (yield* GitCore).createBranch({ cwd: tmp, branch: branchName });
+          yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: branchName });
         }
         yield* git(tmp, ["config", "column.ui", "always"]);
             ),
         ).toBe(true);
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
-        const core = yield* makeIsolatedGitCore((input) =>
+        const core = yield* makeIsolatedGitVcsDriver((input) =>
-          realGitCore.execute(
+          realGitVcsDriver.execute(
             input.args[0] === "branch"
               ? {
                   ...input,
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches.every((b) => b.isDefault === false)).toBe(true);
       }),
     );
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(tmp);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(tmp, ["remote", "add", "origin", remote]);
         yield* git(tmp, ["push", "-u", "origin", defaultBranch]);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/local-only" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "feature/local-only",
+        });
         const remoteOnlyBranch = "feature/remote-only";
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: defaultBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: defaultBranch,
+        });
         yield* git(tmp, ["checkout", "-b", remoteOnlyBranch]);
         yield* git(tmp, ["push", "-u", "origin", remoteOnlyBranch]);
         yield* git(tmp, ["checkout", defaultBranch]);
         yield* git(tmp, ["branch", "-D", remoteOnlyBranch]);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const firstRemoteIndex = result.branches.findIndex((branch) => branch.isRemote);
         expect(result.hasOriginRemote).toBe(true);
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(tmp);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(tmp, ["remote", "add", remoteName, remote]);
         yield* git(tmp, ["push", "-u", remoteName, defaultBranch]);
         yield* git(tmp, ["checkout", defaultBranch]);
         yield* git(tmp, ["branch", "-D", remoteOnlyBranch]);
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const remoteBranch = result.branches.find(
           (branch) => branch.name === `${remoteName}/${remoteOnlyBranch}`,
         );
           yield* git(tmp, ["remote", "add", "origin", remote]);
           yield* git(tmp, ["push", "-u", "origin", initialBranch]);
-          yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/demo" });
+          yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+            cwd: tmp,
+            branch: "feature/demo",
+          });
           yield* git(tmp, ["push", "-u", "origin", "feature/demo"]);
           yield* git(tmp, ["checkout", "-b", "feature/remote-only"]);
           yield* git(tmp, ["checkout", initialBranch]);
           yield* git(tmp, ["branch", "-D", "feature/remote-only"]);
-          const result = yield* (yield* GitCore).listBranches({
+          const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
             cwd: tmp,
             query: "feature/",
             limit: 10,
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "feature" });
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "feature" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "feature" });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const current = result.branches.find((b) => b.current);
         expect(current!.name).toBe("feature");
       }),
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(source, ["remote", "add", "origin", remote]);
         yield* git(source, ["push", "-u", "origin", defaultBranch]);
         const featureBranch = "feature-behind";
-        yield* (yield* GitCore).createBranch({ cwd: source, branch: featureBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: source, branch: featureBranch });
+          cwd: source,
+          branch: featureBranch,
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: source,
+          branch: featureBranch,
+        });
         yield* writeTextFile(path.join(source, "feature.txt"), "feature base\n");
         yield* git(source, ["add", "feature.txt"]);
         yield* git(source, ["commit", "-m", "feature base"]);
         yield* git(source, ["push", "-u", "origin", featureBranch]);
-        yield* (yield* GitCore).checkoutBranch({ cwd: source, branch: defaultBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: source,
+          branch: defaultBranch,
+        });
         yield* git(clone, ["clone", remote, "."]);
         yield* git(clone, ["config", "user.email", "test@test.com"]);
         yield* git(clone, ["commit", "-m", "remote feature update"]);
         yield* git(clone, ["push", "origin", featureBranch]);
-        yield* (yield* GitCore).checkoutBranch({ cwd: source, branch: featureBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
-        const core = yield* GitCore;
+          cwd: source,
+          branch: featureBranch,
+        });
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* Effect.promise(() =>
           vi.waitFor(
             async () => {
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(source, ["remote", "add", "origin", remote]);
         yield* git(source, ["push", "-u", "origin", defaultBranch]);
         yield* git(source, ["push", "-u", "origin", featureBranch]);
         yield* git(source, ["checkout", defaultBranch]);
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let refreshFetchAttempts = 0;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (input.args[0] === "--git-dir" && input.args[2] === "fetch") {
             refreshFetchAttempts += 1;
             return Effect.fail(
               }),
             );
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         yield* core.checkoutBranch({ cwd: source, branch: featureBranch });
         const status = yield* core.statusDetails(source);
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(source, ["remote", "add", "origin", remote]);
         yield* git(source, ["push", "-u", "origin", defaultBranch]);
         yield* git(source, ["push", "-u", "origin", featureBranch]);
         yield* git(source, ["checkout", defaultBranch]);
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let refreshFetchAttempts = 0;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (input.args[0] === "--git-dir" && input.args[2] === "fetch") {
             refreshFetchAttempts += 1;
             return Effect.succeed({
               stderrTruncated: false,
             });
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         yield* core.checkoutBranch({ cwd: source, branch: featureBranch });
         yield* Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, 50)));
           });
         let fetchCount = 0;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (
             input.args[0] === "rev-parse" &&
             input.args[1] === "--abbrev-ref" &&
             ]);
             return ok();
           }
-          if (input.operation === "GitCore.statusDetails.status") {
+          if (input.operation === "GitVcsDriver.statusDetails.status") {
             return ok(
               input.cwd === "/repo/worktrees/pr-123"
                 ? "# branch.head feature/pr-123\n# branch.upstream origin/feature/pr-123\n# branch.ab +0 -0\n"
             );
           }
           if (
-            input.operation === "GitCore.statusDetails.unstagedNumstat" ||
+            input.operation === "GitVcsDriver.statusDetails.unstagedNumstat" ||
-            input.operation === "GitCore.statusDetails.stagedNumstat"
+            input.operation === "GitVcsDriver.statusDetails.stagedNumstat"
           ) {
             return ok();
           }
-          if (input.operation === "GitCore.statusDetails.defaultRef") {
+          if (input.operation === "GitVcsDriver.statusDetails.defaultRef") {
             return ok("refs/remotes/origin/main\n");
           }
           return Effect.fail(
             });
           let fetchCount = 0;
-          const core = yield* makeIsolatedGitCore((input) => {
+          const core = yield* makeIsolatedGitVcsDriver((input) => {
             if (
               input.args[0] === "rev-parse" &&
               input.args[1] === "--abbrev-ref" &&
                 }),
               );
             }
-            if (input.operation === "GitCore.statusDetails.status") {
+            if (input.operation === "GitVcsDriver.statusDetails.status") {
               return ok(
                 input.cwd === "/repo/worktrees/pr-123"
                   ? "# branch.head feature/pr-123\n# branch.upstream origin/feature/pr-123\n# branch.ab +0 -0\n"
               );
             }
             if (
-              input.operation === "GitCore.statusDetails.unstagedNumstat" ||
+              input.operation === "GitVcsDriver.statusDetails.unstagedNumstat" ||
-              input.operation === "GitCore.statusDetails.stagedNumstat"
+              input.operation === "GitVcsDriver.statusDetails.stagedNumstat"
             ) {
               return ok();
             }
-            if (input.operation === "GitCore.statusDetails.defaultRef") {
+            if (input.operation === "GitVcsDriver.statusDetails.defaultRef") {
               return ok("refs/remotes/origin/main\n");
             }
             return Effect.fail(
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
         const result = yield* Effect.result(
-          (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "nonexistent" }),
+          (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "nonexistent" }),
         );
         expect(result._tag).toBe("Failure");
       }),
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(source, ["remote", "add", "origin", remote]);
         yield* git(source, ["push", "-u", "origin", defaultBranch]);
-        yield* (yield* GitCore).createBranch({ cwd: source, branch: "feature" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: source, branch: "feature" });
         const checkoutResult = yield* Effect.result(
-          (yield* GitCore).checkoutBranch({ cwd: source, branch: "origin/feature" }),
+          (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+            cwd: source,
+            branch: "origin/feature",
+          }),
         );
         expect(checkoutResult._tag).toBe("Failure");
         expect(yield* git(source, ["branch", "--show-current"])).toBe(defaultBranch);
         yield* git(prefixRemote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* configureRemote(source, prefixRemoteName, prefixRemote, prefixFetchNamespace);
         yield* configureRemote(source, remoteName, remote, remoteName);
         yield* git(source, ["push", "-u", remoteName, defaultBranch]);
         yield* git(source, ["checkout", defaultBranch]);
         yield* git(source, ["branch", "-D", featureBranch]);
-        const checkoutResult = yield* (yield* GitCore).checkoutBranch({
+        const checkoutResult = yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
           cwd: source,
           branch: `${remoteName}/${featureBranch}`,
         });
         expect(checkoutResult.branch).toBe("upstream/feature");
         expect(yield* git(source, ["branch", "--show-current"])).toBe("upstream/feature");
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let fetchArgs: readonly string[] | null = null;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (input.args[0] === "--git-dir" && input.args[2] === "fetch") {
             fetchArgs = [...input.args];
             return Effect.succeed({
               stderrTruncated: false,
             });
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         const status = yield* core.statusDetails(source);
           yield* git(remote, ["init", "--bare"]);
           yield* initRepoWithCommit(source);
-          const defaultBranch = (yield* (yield* GitCore).listBranches({
+          const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
             cwd: source,
           })).branches.find((branch) => branch.current)!.name;
           yield* git(source, ["remote", "add", "origin", remote]);
           // would attempt to create an already-existing local branch.
           yield* git(source, ["branch", "--unset-upstream"]);
-          yield* (yield* GitCore).checkoutBranch({
+          yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
             cwd: source,
             branch: `origin/${defaultBranch}`,
           });
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const status = yield* core.statusDetails(source);
           expect(status.branch).toBeNull();
         }),
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "other" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "other" });
         // Create a conflicting change: modify README on current branch
         yield* writeTextFile(path.join(tmp, "README.md"), "modified\n");
         // First, checkout other branch cleanly
         yield* git(tmp, ["stash"]);
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "other" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "other" });
         yield* writeTextFile(path.join(tmp, "README.md"), "other content\n");
         yield* git(tmp, ["add", "."]);
         yield* git(tmp, ["commit", "-m", "other change"]);
         // Go back to default branch
-        const defaultBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const defaultBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => !b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => !b.current)!.name;
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: defaultBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: defaultBranch,
+        });
         // Make uncommitted changes to the same file
         yield* writeTextFile(path.join(tmp, "README.md"), "conflicting local\n");
         // Checkout should fail due to uncommitted changes
         const result = yield* Effect.result(
-          (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "other" }),
+          (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "other" }),
         );
         expect(result._tag).toBe("Failure");
       }),
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "new-feature" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "new-feature" });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches.some((b) => b.name === "new-feature")).toBe(true);
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "dupe" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "dupe" });
         const result = yield* Effect.result(
-          (yield* GitCore).createBranch({ cwd: tmp, branch: "dupe" }),
+          (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "dupe" }),
         );
         expect(result._tag).toBe("Failure");
       }),
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/old-name" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "feature/old-name" });
+          cwd: tmp,
+          branch: "feature/old-name",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "feature/old-name",
+        });
-        const renamed = yield* (yield* GitCore).renameBranch({
+        const renamed = yield* (yield* GitVcsDriver.GitVcsDriver).renameBranch({
           cwd: tmp,
           oldBranch: "feature/old-name",
           newBranch: "feature/new-name",
         expect(renamed.branch).toBe("feature/new-name");
-        const branches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const branches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(branches.branches.some((branch) => branch.name === "feature/old-name")).toBe(false);
         const current = branches.branches.find((branch) => branch.current);
         expect(current?.name).toBe("feature/new-name");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const current = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const current = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!;
+        })).branches.find((b) => b.current)!;
-        const renamed = yield* (yield* GitCore).renameBranch({
+        const renamed = yield* (yield* GitVcsDriver.GitVcsDriver).renameBranch({
           cwd: tmp,
           oldBranch: current.name,
           newBranch: current.name,
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "t3code/feat/session" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "t3code/tmp-working" });
+          cwd: tmp,
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "t3code/tmp-working" });
+          branch: "t3code/feat/session",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "t3code/tmp-working",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "t3code/tmp-working",
+        });
-        const renamed = yield* (yield* GitCore).renameBranch({
+        const renamed = yield* (yield* GitVcsDriver.GitVcsDriver).renameBranch({
           cwd: tmp,
           oldBranch: "t3code/tmp-working",
           newBranch: "t3code/feat/session",
         });
         expect(renamed.branch).toBe("t3code/feat/session-1");
-        const branches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const branches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(branches.branches.some((branch) => branch.name === "t3code/feat/session")).toBe(
           true,
         );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "t3code/feat/session" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "t3code/feat/session-1" });
+          cwd: tmp,
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "t3code/tmp-working" });
+          branch: "t3code/feat/session",
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "t3code/tmp-working" });
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "t3code/feat/session-1",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "t3code/tmp-working",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "t3code/tmp-working",
+        });
-        const renamed = yield* (yield* GitCore).renameBranch({
+        const renamed = yield* (yield* GitVcsDriver.GitVcsDriver).renameBranch({
           cwd: tmp,
           oldBranch: "t3code/tmp-working",
           newBranch: "t3code/feat/session",
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/old-name" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "feature/old-name" });
+          cwd: tmp,
+          branch: "feature/old-name",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "feature/old-name",
+        });
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let renameArgs: ReadonlyArray<string> | null = null;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (input.args[0] === "branch" && input.args[1] === "-m") {
             renameArgs = [...input.args];
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         const renamed = yield* core.renameBranch({
         yield* initRepoWithCommit(tmp);
         const wtPath = path.join(tmp, "worktree-out");
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
-        const result = yield* (yield* GitCore).createWorktree({
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: currentBranch,
           newBranch: "wt-branch",
         expect(existsSync(path.join(wtPath, "README.md"))).toBe(true);
         // Clean up worktree before tmp dir disposal
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
       }),
     );
         yield* initRepoWithCommit(tmp);
         const wtPath = path.join(tmp, "wt-check-dir");
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
-        yield* (yield* GitCore).createWorktree({
+        yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: currentBranch,
           newBranch: "wt-check",
         const branchOutput = yield* git(wtPath, ["branch", "--show-current"]);
         expect(branchOutput).toBe("wt-check");
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/existing-worktree" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
+          cwd: tmp,
+          branch: "feature/existing-worktree",
+        });
         const wtPath = path.join(tmp, "wt-existing");
-        const result = yield* (yield* GitCore).createWorktree({
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: "feature/existing-worktree",
           path: wtPath,
         const branchOutput = yield* git(wtPath, ["branch", "--show-current"]);
         expect(branchOutput).toBe("feature/existing-worktree");
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "existing" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "existing" });
         const wtPath = path.join(tmp, "wt-conflict");
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
         const result = yield* Effect.result(
-          (yield* GitCore).createWorktree({
+          (yield* GitVcsDriver.GitVcsDriver).createWorktree({
             cwd: tmp,
             branch: currentBranch,
             newBranch: "existing",
         yield* initRepoWithCommit(tmp);
         const wtPath = path.join(tmp, "wt-list-dir");
-        const mainBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const mainBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
-        yield* (yield* GitCore).createWorktree({
+        yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: mainBranch,
           newBranch: "wt-list",
         });
         // listGitBranches from the worktree should show wt-list as current
-        const wtBranches = yield* (yield* GitCore).listBranches({ cwd: wtPath });
+        const wtBranches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: wtPath });
         expect(wtBranches.isRepo).toBe(true);
         const wtCurrent = wtBranches.branches.find((b) => b.current);
         expect(wtCurrent!.name).toBe("wt-list");
         // Main repo should still show the original branch as current
-        const mainBranches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const mainBranches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const mainCurrent = mainBranches.branches.find((b) => b.current);
         expect(mainCurrent!.name).toBe(mainBranch);
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
       }),
     );
         yield* initRepoWithCommit(tmp);
         const wtPath = path.join(tmp, "wt-remove-dir");
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
-        yield* (yield* GitCore).createWorktree({
+        yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: currentBranch,
           newBranch: "wt-remove",
         });
         expect(existsSync(wtPath)).toBe(true);
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
         expect(existsSync(wtPath)).toBe(false);
       }),
     );
         yield* initRepoWithCommit(tmp);
         const wtPath = path.join(tmp, "wt-dirty-dir");
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
-        yield* (yield* GitCore).createWorktree({
+        yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: currentBranch,
           newBranch: "wt-dirty",
         yield* writeTextFile(path.join(wtPath, "README.md"), "dirty change\n");
         const failedRemove = yield* Effect.result(
-          (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath }),
+          (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath }),
         );
         expect(failedRemove._tag).toBe("Failure");
         expect(existsSync(wtPath)).toBe(true);
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath, force: true });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({
+          cwd: tmp,
+          path: wtPath,
+          force: true,
+        });
         expect(existsSync(wtPath)).toBe(false);
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature-login" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "feature-login" });
+          cwd: tmp,
+          branch: "feature-login",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "feature-login",
+        });
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const current = result.branches.find((b) => b.current);
         expect(current!.name).toBe("feature-login");
       }),
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const currentBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const currentBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (b) => b.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((b) => b.current)!.name;
         const wtPath = path.join(tmp, "my-worktree");
-        const result = yield* (yield* GitCore).createWorktree({
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).createWorktree({
           cwd: tmp,
           branch: currentBranch,
           newBranch: "feature-wt",
         expect(existsSync(result.worktree.path)).toBe(true);
         // Main repo still on original branch
-        const mainBranches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const mainBranches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const mainCurrent = mainBranches.branches.find((b) => b.current);
         expect(mainCurrent!.name).toBe(currentBranch);
         const wtBranch = yield* git(wtPath, ["branch", "--show-current"]);
         expect(wtBranch).toBe("feature-wt");
-        yield* (yield* GitCore).removeWorktree({ cwd: tmp, path: wtPath });
+        yield* (yield* GitVcsDriver.GitVcsDriver).removeWorktree({ cwd: tmp, path: wtPath });
       }),
     );
   });
         yield* git(tmp, ["push", "origin", "HEAD:refs/pull/55/head"]);
         yield* git(tmp, ["checkout", initialBranch]);
-        yield* (yield* GitCore).fetchPullRequestBranch({
+        yield* (yield* GitVcsDriver.GitVcsDriver).fetchPullRequestBranch({
           cwd: tmp,
           prNumber: 55,
           branch: "feature/pr-fetch",
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "branch-a" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "branch-a" });
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "branch-b" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "branch-b" });
         // Simulate switching to thread A's branch
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "branch-a" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "branch-a" });
-        let branches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        let branches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(branches.branches.find((b) => b.current)!.name).toBe("branch-a");
         // Simulate switching to thread B's branch
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "branch-b" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "branch-b" });
-        branches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        branches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(branches.branches.find((b) => b.current)!.name).toBe("branch-b");
         // Switch back to thread A
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "branch-a" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "branch-a" });
-        branches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        branches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(branches.branches.find((b) => b.current)!.name).toBe("branch-a");
       }),
     );
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "diverged" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({ cwd: tmp, branch: "diverged" });
         // Make diverged branch have different file content
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "diverged" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "diverged" });
         yield* writeTextFile(path.join(tmp, "README.md"), "diverged content\n");
         yield* git(tmp, ["add", "."]);
         yield* git(tmp, ["commit", "-m", "diverge"]);
         // Actually, let's just get back to the initial branch explicitly
-        const allBranches = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const allBranches = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         const initialBranch = allBranches.branches.find((b) => b.name !== "diverged")!.name;
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: initialBranch });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: initialBranch,
+        });
         // Make local uncommitted changes to the same file
         yield* writeTextFile(path.join(tmp, "README.md"), "local uncommitted\n");
         // Attempt checkout should fail
         const failedCheckout = yield* Effect.result(
-          (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "diverged" }),
+          (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({ cwd: tmp, branch: "diverged" }),
         );
         expect(failedCheckout._tag).toBe("Failure");
         // Current branch should still be the initial one
-        const result = yield* (yield* GitCore).listBranches({ cwd: tmp });
+        const result = yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({ cwd: tmp });
         expect(result.branches.find((b) => b.current)!.name).toBe(initialBranch);
       }),
     );
   });
-  describe("GitCore", () => {
+  describe("GitVcsDriver", () => {
     it.effect("supports branch lifecycle operations through the service API", () =>
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* core.initRepo({ cwd: tmp });
         yield* git(tmp, ["config", "user.email", "test@test.com"]);
         Effect.gen(function* () {
           const tmp = yield* makeTmpDir();
           yield* initRepoWithCommit(tmp);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           yield* git(tmp, ["remote", "add", "origin", "git@github.com:pingdotgg/t3code.git"]);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const clean = yield* core.status({ cwd: tmp });
         expect(clean.hasWorkingTreeChanges).toBe(false);
         const deletedDir = path.join(tmp, "deleted-repo");
         yield* makeDirectory(deletedDir);
         yield* removePath(deletedDir);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const status = yield* core.statusDetails(deletedDir);
         const localStatus = yield* core.statusDetailsLocal(deletedDir);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* core.createBranch({ cwd: tmp, branch: "feature/no-upstream-ahead" });
         yield* core.checkoutBranch({ cwd: tmp, branch: "feature/no-upstream-ahead" });
           yield* git(remote, ["init", "--bare"]);
           yield* initRepoWithCommit(source);
-          const initialBranch = (yield* (yield* GitCore).listBranches({
+          const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
             cwd: source,
           })).branches.find((branch) => branch.current)!.name;
           yield* git(source, ["remote", "add", "origin", remote]);
           yield* git(source, ["commit", "-m", "feature commit"]);
           yield* git(source, ["branch", "-D", initialBranch]);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const details = yield* core.statusDetails(source);
           expect(details.branch).toBe("feature/remote-base-only");
           expect(details.hasUpstream).toBe(false);
           yield* git(remote, ["init", "--bare"]);
           yield* initRepoWithCommit(source);
-          const initialBranch = (yield* (yield* GitCore).listBranches({
+          const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
             cwd: source,
           })).branches.find((branch) => branch.current)!.name;
           yield* git(source, ["remote", "add", remoteName, remote]);
           yield* git(source, ["commit", "-m", "feature commit"]);
           yield* git(source, ["branch", "-D", initialBranch]);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const details = yield* core.statusDetails(source);
           expect(details.branch).toBe("feature/non-origin-merge-base");
           expect(details.hasUpstream).toBe(false);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* core.createBranch({ cwd: tmp, branch: "feature/no-upstream-no-ahead" });
         yield* core.checkoutBranch({ cwd: tmp, branch: "feature/no-upstream-no-ahead" });
         yield* git(tmp, ["remote", "add", "origin", remote]);
         yield* git(tmp, ["checkout", "-b", "feature/no-base"]);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const pushed = yield* core.pushCurrentBranch(tmp, null);
         expect(pushed.status).toBe("pushed");
         expect(pushed.setUpstream).toBe(true);
         yield* git(tmp, ["remote", "add", "fork", remote]);
         yield* git(tmp, ["checkout", "-b", "feature/fork-only"]);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const pushed = yield* core.pushCurrentBranch(tmp, null);
         expect(pushed.status).toBe("pushed");
         expect(pushed.setUpstream).toBe(true);
           yield* git(remote, ["init", "--bare"]);
           yield* initRepoWithCommit(tmp);
-          const initialBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+          const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-            (branch) => branch.current,
+            cwd: tmp,
-          )!.name;
+          })).branches.find((branch) => branch.current)!.name;
           yield* git(tmp, ["remote", "add", "origin", remote]);
           yield* git(tmp, ["push", "-u", "origin", initialBranch]);
           const featureBranch = "feature/publish-no-upstream";
           yield* git(tmp, ["checkout", "-b", featureBranch]);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const pushed = yield* core.pushCurrentBranch(tmp, null);
           expect(pushed.status).toBe("pushed");
           expect(pushed.setUpstream).toBe(true);
         yield* git(fork, ["init", "--bare"]);
         yield* initRepoWithCommit(tmp);
-        const initialBranch = (yield* (yield* GitCore).listBranches({ cwd: tmp })).branches.find(
+        const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: tmp,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(tmp, ["remote", "add", "origin", origin]);
         yield* git(tmp, ["remote", "add", "fork", fork]);
         yield* git(tmp, ["push", "-u", "origin", initialBranch]);
         yield* git(tmp, ["add", "feature.txt"]);
         yield* git(tmp, ["commit", "-m", "feature commit"]);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const pushed = yield* core.pushCurrentBranch(tmp, null);
         expect(pushed.status).toBe("pushed");
         expect(pushed.setUpstream).toBe(true);
           yield* git(tmp, ["add", "fork.txt"]);
           yield* git(tmp, ["commit", "-m", "update reviewed PR branch"]);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const pushed = yield* core.pushCurrentBranch(tmp, null);
           expect(pushed.status).toBe("pushed");
         yield* git(tmp, ["add", "feature.txt"]);
         yield* git(tmp, ["commit", "-m", "feature update"]);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const pushed = yield* core.pushCurrentBranch(tmp, null);
         expect(pushed.status).toBe("pushed");
         expect(pushed.setUpstream).toBe(false);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const missingWorktreePath = path.join(tmp, "missing-worktree");
         const removeResult = yield* Effect.result(
           yield* git(remote, ["init", "--bare"]);
           yield* initRepoWithCommit(source);
-          const initialBranch = (yield* (yield* GitCore).listBranches({
+          const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
             cwd: source,
           })).branches.find((branch) => branch.current)!.name;
           yield* git(source, ["remote", "add", "origin", remote]);
           yield* git(clone, ["commit", "-m", "remote update"]);
           yield* git(clone, ["push", "origin", initialBranch]);
-          const core = yield* GitCore;
+          const core = yield* GitVcsDriver.GitVcsDriver;
           const details = yield* core.statusDetails(source);
           expect(details.branch).toBe(initialBranch);
           expect(details.aheadCount).toBe(0);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* writeTextFile(path.join(tmp, "README.md"), "new content\n");
         const context = yield* core.prepareCommitContext(tmp);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* writeTextFile(path.join(tmp, "a.txt"), "file a\n");
         yield* writeTextFile(path.join(tmp, "b.txt"), "file b\n");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* writeTextFile(path.join(tmp, "a.txt"), "file a\n");
         yield* writeTextFile(path.join(tmp, "b.txt"), "file b\n");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* writeTextFile(path.join(tmp, "README.md"), buildLargeText());
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         const { initialBranch } = yield* initRepoWithCommit(tmp);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         yield* core.createBranch({ cwd: tmp, branch: "feature/large-range-context" });
         yield* core.checkoutBranch({ cwd: tmp, branch: "feature/large-range-context" });
         yield* initRepoWithCommit(tmp);
         yield* git(remote, ["init", "--bare"]);
         yield* git(tmp, ["remote", "add", "origin", remote]);
-        yield* (yield* GitCore).createBranch({ cwd: tmp, branch: "feature/core-push" });
+        yield* (yield* GitVcsDriver.GitVcsDriver).createBranch({
-        yield* (yield* GitCore).checkoutBranch({ cwd: tmp, branch: "feature/core-push" });
+          cwd: tmp,
+          branch: "feature/core-push",
+        });
+        yield* (yield* GitVcsDriver.GitVcsDriver).checkoutBranch({
+          cwd: tmp,
+          branch: "feature/core-push",
+        });
         yield* writeTextFile(path.join(tmp, "feature.txt"), "push me\n");
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const context = yield* core.prepareCommitContext(tmp);
         expect(context).not.toBeNull();
         yield* core.commit(tmp, "Add feature file", "");
         yield* git(remote, ["init", "--bare"]);
         yield* initRepoWithCommit(source);
-        const initialBranch = (yield* (yield* GitCore).listBranches({ cwd: source })).branches.find(
+        const initialBranch = (yield* (yield* GitVcsDriver.GitVcsDriver).listBranches({
-          (branch) => branch.current,
+          cwd: source,
-        )!.name;
+        })).branches.find((branch) => branch.current)!.name;
         yield* git(source, ["remote", "add", "origin", remote]);
         yield* git(source, ["push", "-u", "origin", initialBranch]);
         yield* git(clone, ["commit", "-m", "remote update"]);
         yield* git(clone, ["push", "origin", initialBranch]);
-        const core = yield* GitCore;
+        const core = yield* GitVcsDriver.GitVcsDriver;
         const pulled = yield* core.pullCurrentBranch(source);
         expect(pulled.status).toBe("pulled");
         expect((yield* core.statusDetails(source)).behindCount).toBe(0);
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const result = yield* Effect.result((yield* GitCore).pullCurrentBranch(tmp));
+        const result = yield* Effect.result(
+          (yield* GitVcsDriver.GitVcsDriver).pullCurrentBranch(tmp),
+        );
         expect(result._tag).toBe("Failure");
         if (result._tag === "Failure") {
           expect(result.failure.message.toLowerCase()).toContain("no upstream");
       Effect.gen(function* () {
         const tmp = yield* makeTmpDir();
         yield* initRepoWithCommit(tmp);
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let didFailRecency = false;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (!didFailRecency && input.args[0] === "for-each-ref") {
             didFailRecency = true;
             return Effect.fail(
               }),
             );
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         const result = yield* core.listBranches({ cwd: tmp });
         yield* git(remote, ["init", "--bare"]);
         yield* git(tmp, ["remote", "add", "origin", remote]);
-        const realGitCore = yield* GitCore;
+        const realGitVcsDriver = yield* GitVcsDriver.GitVcsDriver;
         let didFailRemoteBranches = false;
         let didFailRemoteNames = false;
-        const core = yield* makeIsolatedGitCore((input) => {
+        const core = yield* makeIsolatedGitVcsDriver((input) => {
           if (input.args.join(" ") === "branch --no-color --no-column --remotes") {
             didFailRemoteBranches = true;
             return Effect.fail(
               }),
             );
           }
-          return realGitCore.execute(input);
+          return realGitVcsDriver.execute(input);
         });
         const result = yield* core.listBranches({ cwd: tmp });

apps/server/src/vcs/GitVcsDriverCore.tsrenamed from apps/server/src/git/Layers/GitCore.ts+365−353

@@ -5,7 +5,6 @@ import { · 4 unmodified lines
5	Effect,	5	Effect,
6	Exit,	6	Exit,
7	FileSystem,	7	FileSystem,
8	Layer,
9	Option,	8	Option,
10	Path,	9	Path,
11	PlatformError,	10	PlatformError,
@@ -20,23 +19,22 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; · 8 unmodified lines
20		19
21	import { GitCommandError, type GitBranch } from "@t3tools/contracts";	20	import { GitCommandError, type GitBranch } from "@t3tools/contracts";
22	import { dedupeRemoteBranchesWithLocalMatches } from "@t3tools/shared/git";	21	import { dedupeRemoteBranchesWithLocalMatches } from "@t3tools/shared/git";
23	import { compactTraceAttributes } from "../../observability/Attributes.ts";	22	import { compactTraceAttributes } from "../observability/Attributes.ts";
24	import { gitCommandDuration, gitCommandsTotal, withMetrics } from "../../observability/Metrics.ts";	23	import { gitCommandDuration, gitCommandsTotal, withMetrics } from "../observability/Metrics.ts";
25	import {	24	import type {
26	GitCore,	25	ExecuteGitProgress,
27	type ExecuteGitProgress,	26	GitCommitOptions,
28	type GitCommitOptions,	27	GitVcsDriverShape,
29	type GitCoreShape,	28	GitStatusDetails,
30	type GitStatusDetails,	29	ExecuteGitInput,
31	type ExecuteGitInput,	30	ExecuteGitResult,
32	type ExecuteGitResult,	31	} from "./GitVcsDriver.ts";
33	} from "../Services/GitCore.ts";
34	import {	32	import {
35	parseRemoteNames,	33	parseRemoteNames,
36	parseRemoteNamesInGitOrder,	34	parseRemoteNamesInGitOrder,
37	parseRemoteRefWithRemoteNames,	35	parseRemoteRefWithRemoteNames,
38	} from "../remoteRefs.ts";	36	} from "../git/remoteRefs.ts";
39	import { ServerConfig } from "../../config.ts";	37	import { ServerConfig } from "../config.ts";
40	import { decodeJsonResult } from "@t3tools/shared/schemaJson";	38	import { decodeJsonResult } from "@t3tools/shared/schemaJson";
41		39
42	const DEFAULT_TIMEOUT_MS = 30_000;	40	const DEFAULT_TIMEOUT_MS = 30_000;
@@ -411,7 +409,7 @@ const createTrace2Monitor = Effect.fn("createTrace2Monitor")(function* ( · 368 unmodified lines
411	const traceRecord = decodeJsonResult(Trace2Record)(trimmedLine);	409	const traceRecord = decodeJsonResult(Trace2Record)(trimmedLine);
412	if (Result.isFailure(traceRecord)) {	410	if (Result.isFailure(traceRecord)) {
413	yield* Effect.logDebug(	411	yield* Effect.logDebug(
414	`GitCore.trace2: failed to parse trace line for ${quoteGitCommand(input.args)} in ${input.cwd}`,	412	`GitVcsDriver.trace2: failed to parse trace line for ${quoteGitCommand(input.args)} in ${input.cwd}`,
415	traceRecord.failure,	413	traceRecord.failure,
416	);	414	);
417	return;	415	return;
@@ -604,14 +602,14 @@ const collectOutput = Effect.fn("collectOutput")(function* <E>( · 186 unmodified lines
604	};	602	};
605	});	603	});
606		604
607	export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: {	605	export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* (options?: {
608	executeOverride?: GitCoreShape["execute"];	606	executeOverride?: GitVcsDriverShape["execute"];
609	}) {	607	}) {
610	const fileSystem = yield* FileSystem.FileSystem;	608	const fileSystem = yield* FileSystem.FileSystem;
611	const path = yield* Path.Path;	609	const path = yield* Path.Path;
612	const { worktreesDir } = yield* ServerConfig;	610	const { worktreesDir } = yield* ServerConfig;
613		611
614	let executeRaw: GitCoreShape["execute"];	612	let executeRaw: GitVcsDriverShape["execute"];
615		613
616	if (options?.executeOverride) {	614	if (options?.executeOverride) {
617	executeRaw = options.executeOverride;	615	executeRaw = options.executeOverride;
@@ -718,7 +716,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 100 unmodified lines
718	});	716	});
719	}	717	}
720		718
721	const execute: GitCoreShape["execute"] = (input) =>	719	const execute: GitVcsDriverShape["execute"] = (input) =>
722	executeRaw(input).pipe(	720	executeRaw(input).pipe(
723	withMetrics({	721	withMetrics({
724	counter: gitCommandsTotal,	722	counter: gitCommandsTotal,
@@ -812,7 +810,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 87 unmodified lines
812		810
813	const branchExists = (cwd: string, branch: string): Effect.Effect<boolean, GitCommandError> =>	811	const branchExists = (cwd: string, branch: string): Effect.Effect<boolean, GitCommandError> =>
814	executeGit(	812	executeGit(
815	"GitCore.branchExists",	813	"GitVcsDriver.branchExists",
816	cwd,	814	cwd,
817	["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],	815	["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
818	{	816	{
@@ -839,7 +837,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 20 unmodified lines
839	}	837	}
840		838
841	return yield* createGitCommandError(	839	return yield* createGitCommandError(
842	"GitCore.renameBranch",	840	"GitVcsDriver.renameBranch",
843	cwd,	841	cwd,
844	["branch", "-m", "--", desiredBranch],	842	["branch", "-m", "--", desiredBranch],
845	`Could not find an available branch name for '${desiredBranch}'.`,	843	`Could not find an available branch name for '${desiredBranch}'.`,
@@ -848,7 +846,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
848		846
849	const resolveCurrentUpstream = Effect.fn("resolveCurrentUpstream")(function* (cwd: string) {	847	const resolveCurrentUpstream = Effect.fn("resolveCurrentUpstream")(function* (cwd: string) {
850	const upstreamRef = yield* runGitStdout(	848	const upstreamRef = yield* runGitStdout(
851	"GitCore.resolveCurrentUpstream",	849	"GitVcsDriver.resolveCurrentUpstream",
852	cwd,	850	cwd,
853	["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],	851	["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
854	true,	852	true,
@@ -858,7 +856,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 3 unmodified lines
858	return null;	856	return null;
859	}	857	}
860		858
861	const remoteNames = yield* runGitStdout("GitCore.listRemoteNames", cwd, ["remote"]).pipe(	859	const remoteNames = yield* runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe(
862	Effect.map(parseRemoteNames),	860	Effect.map(parseRemoteNames),
863	Effect.catch(() => Effect.succeed<ReadonlyArray<string>>([])),	861	Effect.catch(() => Effect.succeed<ReadonlyArray<string>>([])),
864	);	862	);
@@ -875,7 +873,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 10 unmodified lines
875	const fetchCwd =	873	const fetchCwd =
876	path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;	874	path.basename(gitCommonDir) === ".git" ? path.dirname(gitCommonDir) : gitCommonDir;
877	return executeGit(	875	return executeGit(
878	"GitCore.fetchRemoteForStatus",	876	"GitVcsDriver.fetchRemoteForStatus",
879	fetchCwd,	877	fetchCwd,
880	["--git-dir", gitCommonDir, "fetch", "--quiet", "--no-tags", remoteName],	878	["--git-dir", gitCommonDir, "fetch", "--quiet", "--no-tags", remoteName],
881	{	879	{
@@ -886,7 +884,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 4 unmodified lines
886	};	884	};
887		885
888	const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) {	886	const resolveGitCommonDir = Effect.fn("resolveGitCommonDir")(function* (cwd: string) {
889	const gitCommonDir = yield* runGitStdout("GitCore.resolveGitCommonDir", cwd, [	887	const gitCommonDir = yield* runGitStdout("GitVcsDriver.resolveGitCommonDir", cwd, [
890	"rev-parse",	888	"rev-parse",
891	"--git-common-dir",	889	"--git-common-dir",
892	]).pipe(Effect.map((stdout) => stdout.trim()));	890	]).pipe(Effect.map((stdout) => stdout.trim()));
@@ -929,7 +927,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 36 unmodified lines
929	remoteName: string,	927	remoteName: string,
930	): Effect.Effect<string \| null, GitCommandError> =>	928	): Effect.Effect<string \| null, GitCommandError> =>
931	executeGit(	929	executeGit(
932	"GitCore.resolveDefaultBranchName",	930	"GitVcsDriver.resolveDefaultBranchName",
933	cwd,	931	cwd,
934	["symbolic-ref", `refs/remotes/${remoteName}/HEAD`],	932	["symbolic-ref", `refs/remotes/${remoteName}/HEAD`],
935	{ allowNonZeroExit: true },	933	{ allowNonZeroExit: true },
@@ -948,7 +946,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 12 unmodified lines
948	branch: string,	946	branch: string,
949	): Effect.Effect<boolean, GitCommandError> =>	947	): Effect.Effect<boolean, GitCommandError> =>
950	executeGit(	948	executeGit(
951	"GitCore.remoteBranchExists",	949	"GitVcsDriver.remoteBranchExists",
952	cwd,	950	cwd,
953	["show-ref", "--verify", "--quiet", `refs/remotes/${remoteName}/${branch}`],	951	["show-ref", "--verify", "--quiet", `refs/remotes/${remoteName}/${branch}`],
954	{	952	{
@@ -957,12 +955,12 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
957	).pipe(Effect.map((result) => result.code === 0));	955	).pipe(Effect.map((result) => result.code === 0));
958		956
959	const originRemoteExists = (cwd: string): Effect.Effect<boolean, GitCommandError> =>	957	const originRemoteExists = (cwd: string): Effect.Effect<boolean, GitCommandError> =>
960	executeGit("GitCore.originRemoteExists", cwd, ["remote", "get-url", "origin"], {	958	executeGit("GitVcsDriver.originRemoteExists", cwd, ["remote", "get-url", "origin"], {
961	allowNonZeroExit: true,	959	allowNonZeroExit: true,
962	}).pipe(Effect.map((result) => result.code === 0));	960	}).pipe(Effect.map((result) => result.code === 0));
963		961
964	const listRemoteNames = (cwd: string): Effect.Effect<ReadonlyArray<string>, GitCommandError> =>	962	const listRemoteNames = (cwd: string): Effect.Effect<ReadonlyArray<string>, GitCommandError> =>
965	runGitStdout("GitCore.listRemoteNames", cwd, ["remote"]).pipe(	963	runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe(
966	Effect.map(parseRemoteNamesInGitOrder),	964	Effect.map(parseRemoteNamesInGitOrder),
967	);	965	);
968		966
@@ -976,7 +974,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 7 unmodified lines
976	return firstRemote;	974	return firstRemote;
977	}	975	}
978	return yield* createGitCommandError(	976	return yield* createGitCommandError(
979	"GitCore.resolvePrimaryRemoteName",	977	"GitVcsDriver.resolvePrimaryRemoteName",
980	cwd,	978	cwd,
981	["remote"],	979	["remote"],
982	"No git remote is configured for this repository.",	980	"No git remote is configured for this repository.",
@@ -988,7 +986,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 5 unmodified lines
988	branch: string,	986	branch: string,
989	) {	987	) {
990	const branchPushRemote = yield* runGitStdout(	988	const branchPushRemote = yield* runGitStdout(
991	"GitCore.resolvePushRemoteName.branchPushRemote",	989	"GitVcsDriver.resolvePushRemoteName.branchPushRemote",
992	cwd,	990	cwd,
993	["config", "--get", `branch.${branch}.pushRemote`],	991	["config", "--get", `branch.${branch}.pushRemote`],
994	true,	992	true,
@@ -998,7 +996,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 3 unmodified lines
998	}	996	}
999		997
1000	const pushDefaultRemote = yield* runGitStdout(	998	const pushDefaultRemote = yield* runGitStdout(
1001	"GitCore.resolvePushRemoteName.remotePushDefault",	999	"GitVcsDriver.resolvePushRemoteName.remotePushDefault",
1002	cwd,	1000	cwd,
1003	["config", "--get", "remote.pushDefault"],	1001	["config", "--get", "remote.pushDefault"],
1004	true,	1002	true,
@@ -1010,37 +1008,45 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 5 unmodified lines
1010	return yield* resolvePrimaryRemoteName(cwd).pipe(Effect.catch(() => Effect.succeed(null)));	1008	return yield* resolvePrimaryRemoteName(cwd).pipe(Effect.catch(() => Effect.succeed(null)));
1011	});	1009	});
1012		1010
1013	const ensureRemote: GitCoreShape["ensureRemote"] = Effect.fn("ensureRemote")(function* (input) {	1011	const ensureRemote: GitVcsDriverShape["ensureRemote"] = Effect.fn("ensureRemote")(
1014	const preferredName = sanitizeRemoteName(input.preferredName);	1012	function* (input) {
1015	const normalizedTargetUrl = normalizeRemoteUrl(input.url);	1013	const preferredName = sanitizeRemoteName(input.preferredName);
1016	const remoteFetchUrls = yield* runGitStdout("GitCore.ensureRemote.listRemoteUrls", input.cwd, [	1014	const normalizedTargetUrl = normalizeRemoteUrl(input.url);
1017	"remote",	1015	const remoteFetchUrls = yield* runGitStdout(
1018	"-v",	1016	"GitVcsDriver.ensureRemote.listRemoteUrls",
1019	]).pipe(Effect.map((stdout) => parseRemoteFetchUrls(stdout)));	1017	input.cwd,
1020		1018	["remote", "-v"],
1021	for (const [remoteName, remoteUrl] of remoteFetchUrls.entries()) {	1019	).pipe(Effect.map((stdout) => parseRemoteFetchUrls(stdout)));
1022	if (normalizeRemoteUrl(remoteUrl) === normalizedTargetUrl) {	1020
1023	return remoteName;	1021	for (const [remoteName, remoteUrl] of remoteFetchUrls.entries()) {
		1022	if (normalizeRemoteUrl(remoteUrl) === normalizedTargetUrl) {
		1023	return remoteName;
		1024	}
1024	}	1025	}
1025	}
1026		1026
1027	let remoteName = preferredName;	1027	let remoteName = preferredName;
1028	let suffix = 1;	1028	let suffix = 1;
1029	while (remoteFetchUrls.has(remoteName)) {	1029	while (remoteFetchUrls.has(remoteName)) {
1030	remoteName = `${preferredName}-${suffix}`;	1030	remoteName = `${preferredName}-${suffix}`;
1031	suffix += 1;	1031	suffix += 1;
1032	}	1032	}
1033		1033
1034	yield* runGit("GitCore.ensureRemote.add", input.cwd, ["remote", "add", remoteName, input.url]);	1034	yield* runGit("GitVcsDriver.ensureRemote.add", input.cwd, [
1035	return remoteName;	1035	"remote",
1036	});	1036	"add",
		1037	remoteName,
		1038	input.url,
		1039	]);
		1040	return remoteName;
		1041	},
		1042	);
1037		1043
1038	const resolveBaseBranchForNoUpstream = Effect.fn("resolveBaseBranchForNoUpstream")(function* (	1044	const resolveBaseBranchForNoUpstream = Effect.fn("resolveBaseBranchForNoUpstream")(function* (
1039	cwd: string,	1045	cwd: string,
1040	branch: string,	1046	branch: string,
1041	) {	1047	) {
1042	const configuredBaseBranch = yield* runGitStdout(	1048	const configuredBaseBranch = yield* runGitStdout(
1043	"GitCore.resolveBaseBranchForNoUpstream.config",	1049	"GitVcsDriver.resolveBaseBranchForNoUpstream.config",
1044	cwd,	1050	cwd,
1045	["config", "--get", `branch.${branch}.gh-merge-base`],	1051	["config", "--get", `branch.${branch}.gh-merge-base`],
1046	true,	1052	true,
@@ -1098,7 +1104,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 51 unmodified lines
1098	}	1104	}
1099		1105
1100	const result = yield* executeGit(	1106	const result = yield* executeGit(
1101	"GitCore.computeAheadCountAgainstBase",	1107	"GitVcsDriver.computeAheadCountAgainstBase",
1102	cwd,	1108	cwd,
1103	["rev-list", "--count", `${baseBranch}..HEAD`],	1109	["rev-list", "--count", `${baseBranch}..HEAD`],
1104	{ allowNonZeroExit: true },	1110	{ allowNonZeroExit: true },
@@ -1113,7 +1119,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 8 unmodified lines
1113		1119
1114	const readBranchRecency = Effect.fn("readBranchRecency")(function* (cwd: string) {	1120	const readBranchRecency = Effect.fn("readBranchRecency")(function* (cwd: string) {
1115	const branchRecency = yield* executeGit(	1121	const branchRecency = yield* executeGit(
1116	"GitCore.readBranchRecency",	1122	"GitVcsDriver.readBranchRecency",
1117	cwd,	1123	cwd,
1118	[	1124	[
1119	"for-each-ref",	1125	"for-each-ref",
@@ -1149,7 +1155,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 29 unmodified lines
1149		1155
1150	const readStatusDetailsLocal = Effect.fn("readStatusDetailsLocal")(function* (cwd: string) {	1156	const readStatusDetailsLocal = Effect.fn("readStatusDetailsLocal")(function* (cwd: string) {
1151	const statusResult = yield* executeGit(	1157	const statusResult = yield* executeGit(
1152	"GitCore.statusDetails.status",	1158	"GitVcsDriver.statusDetails.status",
1153	cwd,	1159	cwd,
1154	["status", "--porcelain=2", "--branch"],	1160	["status", "--porcelain=2", "--branch"],
1155	{	1161	{
@@ -1164,7 +1170,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 8 unmodified lines
1164	if (statusResult.code !== 0) {	1170	if (statusResult.code !== 0) {
1165	const stderr = statusResult.stderr.trim();	1171	const stderr = statusResult.stderr.trim();
1166	return yield* createGitCommandError(	1172	return yield* createGitCommandError(
1167	"GitCore.statusDetails.status",	1173	"GitVcsDriver.statusDetails.status",
1168	cwd,	1174	cwd,
1169	["status", "--porcelain=2", "--branch"],	1175	["status", "--porcelain=2", "--branch"],
1170	stderr \|\| "git status failed",	1176	stderr \|\| "git status failed",
@@ -1174,14 +1180,14 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 3 unmodified lines
1174	const [unstagedNumstatStdout, stagedNumstatStdout, defaultRefResult, hasOriginRemote] =	1180	const [unstagedNumstatStdout, stagedNumstatStdout, defaultRefResult, hasOriginRemote] =
1175	yield* Effect.all(	1181	yield* Effect.all(
1176	[	1182	[
1177	runGitStdout("GitCore.statusDetails.unstagedNumstat", cwd, ["diff", "--numstat"]),	1183	runGitStdout("GitVcsDriver.statusDetails.unstagedNumstat", cwd, ["diff", "--numstat"]),
1178	runGitStdout("GitCore.statusDetails.stagedNumstat", cwd, [	1184	runGitStdout("GitVcsDriver.statusDetails.stagedNumstat", cwd, [
1179	"diff",	1185	"diff",
1180	"--cached",	1186	"--cached",
1181	"--numstat",	1187	"--numstat",
1182	]),	1188	]),
1183	executeGit(	1189	executeGit(
1184	"GitCore.statusDetails.defaultRef",	1190	"GitVcsDriver.statusDetails.defaultRef",
1185	cwd,	1191	cwd,
1186	["symbolic-ref", "refs/remotes/origin/HEAD"],	1192	["symbolic-ref", "refs/remotes/origin/HEAD"],
1187	{	1193	{
@@ -1284,21 +1290,23 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 96 unmodified lines
1284	};	1290	};
1285	});	1291	});
1286		1292
1287	const statusDetailsLocal: GitCoreShape["statusDetailsLocal"] = Effect.fn("statusDetailsLocal")(	1293	const statusDetailsLocal: GitVcsDriverShape["statusDetailsLocal"] = Effect.fn(
		1294	"statusDetailsLocal",
		1295	)(function* (cwd) {
		1296	return yield* readStatusDetailsLocal(cwd);
		1297	});
		1298
		1299	const statusDetails: GitVcsDriverShape["statusDetails"] = Effect.fn("statusDetails")(
1288	function* (cwd) {	1300	function* (cwd) {
		1301	yield* refreshStatusUpstreamIfStale(cwd).pipe(
		1302	Effect.catchIf(isMissingGitCwdError, () => Effect.void),
		1303	Effect.ignoreCause({ log: true }),
		1304	);
1289	return yield* readStatusDetailsLocal(cwd);	1305	return yield* readStatusDetailsLocal(cwd);
1290	},	1306	},
1291	);	1307	);
1292		1308
1293	const statusDetails: GitCoreShape["statusDetails"] = Effect.fn("statusDetails")(function* (cwd) {	1309	const status: GitVcsDriverShape["status"] = (input) =>
1294	yield* refreshStatusUpstreamIfStale(cwd).pipe(
1295	Effect.catchIf(isMissingGitCwdError, () => Effect.void),
1296	Effect.ignoreCause({ log: true }),
1297	);
1298	return yield* readStatusDetailsLocal(cwd);
1299	});
1300
1301	const status: GitCoreShape["status"] = (input) =>
1302	statusDetails(input.cwd).pipe(	1310	statusDetails(input.cwd).pipe(
1303	Effect.map((details) => ({	1311	Effect.map((details) => ({
1304	isRepo: details.isRepo,	1312	isRepo: details.isRepo,
@@ -1314,34 +1322,34 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 9 unmodified lines
1314	})),	1322	})),
1315	);	1323	);
1316		1324
1317	const prepareCommitContext: GitCoreShape["prepareCommitContext"] = Effect.fn(	1325	const prepareCommitContext: GitVcsDriverShape["prepareCommitContext"] = Effect.fn(
1318	"prepareCommitContext",	1326	"prepareCommitContext",
1319	)(function* (cwd, filePaths) {	1327	)(function* (cwd, filePaths) {
1320	if (filePaths && filePaths.length > 0) {	1328	if (filePaths && filePaths.length > 0) {
1321	yield* runGit("GitCore.prepareCommitContext.reset", cwd, ["reset"]).pipe(	1329	yield* runGit("GitVcsDriver.prepareCommitContext.reset", cwd, ["reset"]).pipe(
1322	Effect.catch(() => Effect.void),	1330	Effect.catch(() => Effect.void),
1323	);	1331	);
1324	yield* runGit("GitCore.prepareCommitContext.addSelected", cwd, [	1332	yield* runGit("GitVcsDriver.prepareCommitContext.addSelected", cwd, [
1325	"add",	1333	"add",
1326	"-A",	1334	"-A",
1327	"--",	1335	"--",
1328	...filePaths,	1336	...filePaths,
1329	]);	1337	]);
1330	} else {	1338	} else {
1331	yield* runGit("GitCore.prepareCommitContext.addAll", cwd, ["add", "-A"]);	1339	yield* runGit("GitVcsDriver.prepareCommitContext.addAll", cwd, ["add", "-A"]);
1332	}	1340	}
1333		1341
1334	const stagedSummary = yield* runGitStdout("GitCore.prepareCommitContext.stagedSummary", cwd, [	1342	const stagedSummary = yield* runGitStdout(
1335	"diff",	1343	"GitVcsDriver.prepareCommitContext.stagedSummary",
1336	"--cached",	1344	cwd,
1337	"--name-status",	1345	["diff", "--cached", "--name-status"],
1338	]).pipe(Effect.map((stdout) => stdout.trim()));	1346	).pipe(Effect.map((stdout) => stdout.trim()));
1339	if (stagedSummary.length === 0) {	1347	if (stagedSummary.length === 0) {
1340	return null;	1348	return null;
1341	}	1349	}
1342		1350
1343	const stagedPatch = yield* runGitStdoutWithOptions(	1351	const stagedPatch = yield* runGitStdoutWithOptions(
1344	"GitCore.prepareCommitContext.stagedPatch",	1352	"GitVcsDriver.prepareCommitContext.stagedPatch",
1345	cwd,	1353	cwd,
1346	["diff", "--cached", "--patch", "--minimal"],	1354	["diff", "--cached", "--patch", "--minimal"],
1347	{	1355	{
@@ -1356,7 +1364,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 8 unmodified lines
1356	};	1364	};
1357	});	1365	});
1358		1366
1359	const commit: GitCoreShape["commit"] = Effect.fn("commit")(function* (	1367	const commit: GitVcsDriverShape["commit"] = Effect.fn("commit")(function* (
1360	cwd,	1368	cwd,
1361	subject,	1369	subject,
1362	body,	1370	body,
@@ -1377,11 +1385,11 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 14 unmodified lines
1377	onStderrLine: (line: string) =>	1385	onStderrLine: (line: string) =>
1378	options.progress?.onOutputLine?.({ stream: "stderr", text: line }) ?? Effect.void,	1386	options.progress?.onOutputLine?.({ stream: "stderr", text: line }) ?? Effect.void,
1379	};	1387	};
1380	yield* executeGit("GitCore.commit.commit", cwd, args, {	1388	yield* executeGit("GitVcsDriver.commit.commit", cwd, args, {
1381	...(options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),	1389	...(options?.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
1382	...(progress ? { progress } : {}),	1390	...(progress ? { progress } : {}),
1383	}).pipe(Effect.asVoid);	1391	}).pipe(Effect.asVoid);
1384	const commitSha = yield* runGitStdout("GitCore.commit.revParseHead", cwd, [	1392	const commitSha = yield* runGitStdout("GitVcsDriver.commit.revParseHead", cwd, [
1385	"rev-parse",	1393	"rev-parse",
1386	"HEAD",	1394	"HEAD",
1387	]).pipe(Effect.map((stdout) => stdout.trim()));	1395	]).pipe(Effect.map((stdout) => stdout.trim()));
@@ -1389,13 +1397,13 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 1 unmodified line
1389	return { commitSha };	1397	return { commitSha };
1390	});	1398	});
1391		1399
1392	const pushCurrentBranch: GitCoreShape["pushCurrentBranch"] = Effect.fn("pushCurrentBranch")(	1400	const pushCurrentBranch: GitVcsDriverShape["pushCurrentBranch"] = Effect.fn("pushCurrentBranch")(
1393	function* (cwd, fallbackBranch) {	1401	function* (cwd, fallbackBranch) {
1394	const details = yield* statusDetails(cwd);	1402	const details = yield* statusDetails(cwd);
1395	const branch = details.branch ?? fallbackBranch;	1403	const branch = details.branch ?? fallbackBranch;
1396	if (!branch) {	1404	if (!branch) {
1397	return yield* createGitCommandError(	1405	return yield* createGitCommandError(
1398	"GitCore.pushCurrentBranch",	1406	"GitVcsDriver.pushCurrentBranch",
1399	cwd,	1407	cwd,
1400	["push"],	1408	["push"],
1401	"Cannot push from detached HEAD.",	1409	"Cannot push from detached HEAD.",
@@ -1442,13 +1450,13 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 40 unmodified lines
1442	const publishRemoteName = yield* resolvePushRemoteName(cwd, branch);	1450	const publishRemoteName = yield* resolvePushRemoteName(cwd, branch);
1443	if (!publishRemoteName) {	1451	if (!publishRemoteName) {
1444	return yield* createGitCommandError(	1452	return yield* createGitCommandError(
1445	"GitCore.pushCurrentBranch",	1453	"GitVcsDriver.pushCurrentBranch",
1446	cwd,	1454	cwd,
1447	["push"],	1455	["push"],
1448	"Cannot push because no git remote is configured for this repository.",	1456	"Cannot push because no git remote is configured for this repository.",
1449	);	1457	);
1450	}	1458	}
1451	yield* runGit("GitCore.pushCurrentBranch.pushWithUpstream", cwd, [	1459	yield* runGit("GitVcsDriver.pushCurrentBranch.pushWithUpstream", cwd, [
1452	"push",	1460	"push",
1453	"-u",	1461	"-u",
1454	publishRemoteName,	1462	publishRemoteName,
@@ -1466,7 +1474,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 11 unmodified lines
1466	Effect.catch(() => Effect.succeed(null)),	1474	Effect.catch(() => Effect.succeed(null)),
1467	);	1475	);
1468	if (currentUpstream) {	1476	if (currentUpstream) {
1469	yield* runGit("GitCore.pushCurrentBranch.pushUpstream", cwd, [	1477	yield* runGit("GitVcsDriver.pushCurrentBranch.pushUpstream", cwd, [
1470	"push",	1478	"push",
1471	currentUpstream.remoteName,	1479	currentUpstream.remoteName,
1472	`HEAD:${currentUpstream.upstreamBranch}`,	1480	`HEAD:${currentUpstream.upstreamBranch}`,
@@ -1479,7 +1487,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 6 unmodified lines
1479	};	1487	};
1480	}	1488	}
1481		1489
1482	yield* runGit("GitCore.pushCurrentBranch.push", cwd, ["push"]);	1490	yield* runGit("GitVcsDriver.pushCurrentBranch.push", cwd, ["push"]);
1483	return {	1491	return {
1484	status: "pushed" as const,	1492	status: "pushed" as const,
1485	branch,	1493	branch,
@@ -1489,13 +1497,13 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 3 unmodified lines
1489	},	1497	},
1490	);	1498	);
1491		1499
1492	const pullCurrentBranch: GitCoreShape["pullCurrentBranch"] = Effect.fn("pullCurrentBranch")(	1500	const pullCurrentBranch: GitVcsDriverShape["pullCurrentBranch"] = Effect.fn("pullCurrentBranch")(
1493	function* (cwd) {	1501	function* (cwd) {
1494	const details = yield* statusDetails(cwd);	1502	const details = yield* statusDetails(cwd);
1495	const branch = details.branch;	1503	const branch = details.branch;
1496	if (!branch) {	1504	if (!branch) {
1497	return yield* createGitCommandError(	1505	return yield* createGitCommandError(
1498	"GitCore.pullCurrentBranch",	1506	"GitVcsDriver.pullCurrentBranch",
1499	cwd,	1507	cwd,
1500	["pull", "--ff-only"],	1508	["pull", "--ff-only"],
1501	"Cannot pull from detached HEAD.",	1509	"Cannot pull from detached HEAD.",
@@ -1503,24 +1511,24 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 1 unmodified line
1503	}	1511	}
1504	if (!details.hasUpstream) {	1512	if (!details.hasUpstream) {
1505	return yield* createGitCommandError(	1513	return yield* createGitCommandError(
1506	"GitCore.pullCurrentBranch",	1514	"GitVcsDriver.pullCurrentBranch",
1507	cwd,	1515	cwd,
1508	["pull", "--ff-only"],	1516	["pull", "--ff-only"],
1509	"Current branch has no upstream configured. Push with upstream first.",	1517	"Current branch has no upstream configured. Push with upstream first.",
1510	);	1518	);
1511	}	1519	}
1512	const beforeSha = yield* runGitStdout(	1520	const beforeSha = yield* runGitStdout(
1513	"GitCore.pullCurrentBranch.beforeSha",	1521	"GitVcsDriver.pullCurrentBranch.beforeSha",
1514	cwd,	1522	cwd,
1515	["rev-parse", "HEAD"],	1523	["rev-parse", "HEAD"],
1516	true,	1524	true,
1517	).pipe(Effect.map((stdout) => stdout.trim()));	1525	).pipe(Effect.map((stdout) => stdout.trim()));
1518	yield* executeGit("GitCore.pullCurrentBranch.pull", cwd, ["pull", "--ff-only"], {	1526	yield* executeGit("GitVcsDriver.pullCurrentBranch.pull", cwd, ["pull", "--ff-only"], {
1519	timeoutMs: 30_000,	1527	timeoutMs: 30_000,
1520	fallbackErrorMessage: "git pull failed",	1528	fallbackErrorMessage: "git pull failed",
1521	});	1529	});
1522	const afterSha = yield* runGitStdout(	1530	const afterSha = yield* runGitStdout(
1523	"GitCore.pullCurrentBranch.afterSha",	1531	"GitVcsDriver.pullCurrentBranch.afterSha",
1524	cwd,	1532	cwd,
1525	["rev-parse", "HEAD"],	1533	["rev-parse", "HEAD"],
1526	true,	1534	true,
@@ -1535,13 +1543,13 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 8 unmodified lines
1535	},	1543	},
1536	);	1544	);
1537		1545
1538	const readRangeContext: GitCoreShape["readRangeContext"] = Effect.fn("readRangeContext")(	1546	const readRangeContext: GitVcsDriverShape["readRangeContext"] = Effect.fn("readRangeContext")(
1539	function* (cwd, baseBranch) {	1547	function* (cwd, baseBranch) {
1540	const range = `${baseBranch}..HEAD`;	1548	const range = `${baseBranch}..HEAD`;
1541	const [commitSummary, diffSummary, diffPatch] = yield* Effect.all(	1549	const [commitSummary, diffSummary, diffPatch] = yield* Effect.all(
1542	[	1550	[
1543	runGitStdoutWithOptions(	1551	runGitStdoutWithOptions(
1544	"GitCore.readRangeContext.log",	1552	"GitVcsDriver.readRangeContext.log",
1545	cwd,	1553	cwd,
1546	["log", "--oneline", range],	1554	["log", "--oneline", range],
1547	{	1555	{
@@ -1550,7 +1558,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
1550	},	1558	},
1551	),	1559	),
1552	runGitStdoutWithOptions(	1560	runGitStdoutWithOptions(
1553	"GitCore.readRangeContext.diffStat",	1561	"GitVcsDriver.readRangeContext.diffStat",
1554	cwd,	1562	cwd,
1555	["diff", "--stat", range],	1563	["diff", "--stat", range],
1556	{	1564	{
@@ -1559,7 +1567,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
1559	},	1567	},
1560	),	1568	),
1561	runGitStdoutWithOptions(	1569	runGitStdoutWithOptions(
1562	"GitCore.readRangeContext.diffPatch",	1570	"GitVcsDriver.readRangeContext.diffPatch",
1563	cwd,	1571	cwd,
1564	["diff", "--patch", "--minimal", range],	1572	["diff", "--patch", "--minimal", range],
1565	{	1573	{
@@ -1579,228 +1587,230 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 13 unmodified lines
1579	},	1587	},
1580	);	1588	);
1581		1589
1582	const readConfigValue: GitCoreShape["readConfigValue"] = (cwd, key) =>	1590	const readConfigValue: GitVcsDriverShape["readConfigValue"] = (cwd, key) =>
1583	runGitStdout("GitCore.readConfigValue", cwd, ["config", "--get", key], true).pipe(	1591	runGitStdout("GitVcsDriver.readConfigValue", cwd, ["config", "--get", key], true).pipe(
1584	Effect.map((stdout) => stdout.trim()),	1592	Effect.map((stdout) => stdout.trim()),
1585	Effect.map((trimmed) => (trimmed.length > 0 ? trimmed : null)),	1593	Effect.map((trimmed) => (trimmed.length > 0 ? trimmed : null)),
1586	);	1594	);
1587		1595
1588	const listBranches: GitCoreShape["listBranches"] = Effect.fn("listBranches")(function* (input) {	1596	const listBranches: GitVcsDriverShape["listBranches"] = Effect.fn("listBranches")(
1589	const branchRecencyPromise = readBranchRecency(input.cwd).pipe(	1597	function* (input) {
1590	Effect.catch(() => Effect.succeed(new Map<string, number>())),	1598	const branchRecencyPromise = readBranchRecency(input.cwd).pipe(
1591	);	1599	Effect.catch(() => Effect.succeed(new Map<string, number>())),
1592	const localBranchResult = yield* executeGit(	1600	);
1593	"GitCore.listBranches.branchNoColor",	1601	const localBranchResult = yield* executeGit(
1594	input.cwd,	1602	"GitVcsDriver.listBranches.branchNoColor",
1595	["branch", "--no-color", "--no-column"],
1596	{
1597	timeoutMs: 10_000,
1598	allowNonZeroExit: true,
1599	},
1600	).pipe(
1601	Effect.catchIf(isMissingGitCwdError, () =>
1602	Effect.succeed({
1603	code: 128,
1604	stdout: "",
1605	stderr: "fatal: not a git repository",
1606	stdoutTruncated: false,
1607	stderrTruncated: false,
1608	}),
1609	),
1610	);
1611
1612	if (localBranchResult.code !== 0) {
1613	const stderr = localBranchResult.stderr.trim();
1614	if (stderr.toLowerCase().includes("not a git repository")) {
1615	return {
1616	branches: [],
1617	isRepo: false,
1618	hasOriginRemote: false,
1619	nextCursor: null,
1620	totalCount: 0,
1621	};
1622	}
1623	return yield* createGitCommandError(
1624	"GitCore.listBranches",
1625	input.cwd,	1603	input.cwd,
1626	["branch", "--no-color", "--no-column"],	1604	["branch", "--no-color", "--no-column"],
1627	stderr \|\| "git branch failed",	1605	{
		1606	timeoutMs: 10_000,
		1607	allowNonZeroExit: true,
		1608	},
		1609	).pipe(
		1610	Effect.catchIf(isMissingGitCwdError, () =>
		1611	Effect.succeed({
		1612	code: 128,
		1613	stdout: "",
		1614	stderr: "fatal: not a git repository",
		1615	stdoutTruncated: false,
		1616	stderrTruncated: false,
		1617	}),
		1618	),
1628	);	1619	);
1629	}
1630		1620
1631	const remoteBranchResultEffect = executeGit(	1621	if (localBranchResult.code !== 0) {
1632	"GitCore.listBranches.remoteBranches",	1622	const stderr = localBranchResult.stderr.trim();
1633	input.cwd,	1623	if (stderr.toLowerCase().includes("not a git repository")) {
1634	["branch", "--no-color", "--no-column", "--remotes"],	1624	return {
1635	{	1625	branches: [],
1636	timeoutMs: 10_000,	1626	isRepo: false,
1637	allowNonZeroExit: true,	1627	hasOriginRemote: false,
1638	},	1628	nextCursor: null,
1639	).pipe(	1629	totalCount: 0,
1640	Effect.catch((error) =>	1630	};
1641	Effect.logWarning(	1631	}
1642	`GitCore.listBranches: remote branch lookup failed for ${input.cwd}: ${error.message}. Falling back to an empty remote branch list.`,	1632	return yield* createGitCommandError(
1643	).pipe(Effect.as({ code: 1, stdout: "", stderr: "" })),	1633	"GitVcsDriver.listBranches",
1644	),	1634	input.cwd,
1645	);	1635	["branch", "--no-color", "--no-column"],
1646		1636	stderr \|\| "git branch failed",
1647	const remoteNamesResultEffect = executeGit(	1637	);
1648	"GitCore.listBranches.remoteNames",	1638	}
1649	input.cwd,
1650	["remote"],
1651	{
1652	timeoutMs: 5_000,
1653	allowNonZeroExit: true,
1654	},
1655	).pipe(
1656	Effect.catch((error) =>
1657	Effect.logWarning(
1658	`GitCore.listBranches: remote name lookup failed for ${input.cwd}: ${error.message}. Falling back to an empty remote name list.`,
1659	).pipe(Effect.as({ code: 1, stdout: "", stderr: "" })),
1660	),
1661	);
1662		1639
1663	const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =	1640	const remoteBranchResultEffect = executeGit(
1664	yield* Effect.all(	1641	"GitVcsDriver.listBranches.remoteBranches",
1665	[	1642	input.cwd,
1666	executeGit(	1643	["branch", "--no-color", "--no-column", "--remotes"],
1667	"GitCore.listBranches.defaultRef",	1644	{
1668	input.cwd,	1645	timeoutMs: 10_000,
1669	["symbolic-ref", "refs/remotes/origin/HEAD"],	1646	allowNonZeroExit: true,
1670	{	1647	},
1671	timeoutMs: 5_000,	1648	).pipe(
1672	allowNonZeroExit: true,	1649	Effect.catch((error) =>
1673	},	1650	Effect.logWarning(
1674	),	1651	`GitVcsDriver.listBranches: remote branch lookup failed for ${input.cwd}: ${error.message}. Falling back to an empty remote branch list.`,
1675	executeGit(	1652	).pipe(Effect.as({ code: 1, stdout: "", stderr: "" })),
1676	"GitCore.listBranches.worktreeList",	1653	),
1677	input.cwd,
1678	["worktree", "list", "--porcelain"],
1679	{
1680	timeoutMs: 5_000,
1681	allowNonZeroExit: true,
1682	},
1683	),
1684	remoteBranchResultEffect,
1685	remoteNamesResultEffect,
1686	branchRecencyPromise,
1687	],
1688	{ concurrency: "unbounded" },
1689	);	1654	);
1690		1655
1691	const remoteNames =	1656	const remoteNamesResultEffect = executeGit(
1692	remoteNamesResult.code === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];	1657	"GitVcsDriver.listBranches.remoteNames",
1693	if (remoteBranchResult.code !== 0 && remoteBranchResult.stderr.trim().length > 0) {	1658	input.cwd,
1694	yield* Effect.logWarning(	1659	["remote"],
1695	`GitCore.listBranches: remote branch lookup returned code ${remoteBranchResult.code} for ${input.cwd}: ${remoteBranchResult.stderr.trim()}. Falling back to an empty remote branch list.`,	1660	{
1696	);	1661	timeoutMs: 5_000,
1697	}	1662	allowNonZeroExit: true,
1698	if (remoteNamesResult.code !== 0 && remoteNamesResult.stderr.trim().length > 0) {	1663	},
1699	yield* Effect.logWarning(	1664	).pipe(
1700	`GitCore.listBranches: remote name lookup returned code ${remoteNamesResult.code} for ${input.cwd}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,	1665	Effect.catch((error) =>
		1666	Effect.logWarning(
		1667	`GitVcsDriver.listBranches: remote name lookup failed for ${input.cwd}: ${error.message}. Falling back to an empty remote name list.`,
		1668	).pipe(Effect.as({ code: 1, stdout: "", stderr: "" })),
		1669	),
1701	);	1670	);
1702	}
1703		1671
1704	const defaultBranch =	1672	const [defaultRef, worktreeList, remoteBranchResult, remoteNamesResult, branchLastCommit] =
1705	defaultRef.code === 0	1673	yield* Effect.all(
1706	? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "")	1674	[
1707	: null;	1675	executeGit(
		1676	"GitVcsDriver.listBranches.defaultRef",
		1677	input.cwd,
		1678	["symbolic-ref", "refs/remotes/origin/HEAD"],
		1679	{
		1680	timeoutMs: 5_000,
		1681	allowNonZeroExit: true,
		1682	},
		1683	),
		1684	executeGit(
		1685	"GitVcsDriver.listBranches.worktreeList",
		1686	input.cwd,
		1687	["worktree", "list", "--porcelain"],
		1688	{
		1689	timeoutMs: 5_000,
		1690	allowNonZeroExit: true,
		1691	},
		1692	),
		1693	remoteBranchResultEffect,
		1694	remoteNamesResultEffect,
		1695	branchRecencyPromise,
		1696	],
		1697	{ concurrency: "unbounded" },
		1698	);
1708		1699
1709	const worktreeMap = new Map<string, string>();	1700	const remoteNames =
1710	if (worktreeList.code === 0) {	1701	remoteNamesResult.code === 0 ? parseRemoteNames(remoteNamesResult.stdout) : [];
1711	let currentPath: string \| null = null;	1702	if (remoteBranchResult.code !== 0 && remoteBranchResult.stderr.trim().length > 0) {
1712	for (const line of worktreeList.stdout.split("\n")) {	1703	yield* Effect.logWarning(
1713	if (line.startsWith("worktree ")) {	1704	`GitVcsDriver.listBranches: remote branch lookup returned code ${remoteBranchResult.code} for ${input.cwd}: ${remoteBranchResult.stderr.trim()}. Falling back to an empty remote branch list.`,
1714	const candidatePath = line.slice("worktree ".length);	1705	);
1715	const exists = yield* fileSystem.stat(candidatePath).pipe(	1706	}
1716	Effect.map(() => true),	1707	if (remoteNamesResult.code !== 0 && remoteNamesResult.stderr.trim().length > 0) {
1717	Effect.catch(() => Effect.succeed(false)),	1708	yield* Effect.logWarning(
1718	);	1709	`GitVcsDriver.listBranches: remote name lookup returned code ${remoteNamesResult.code} for ${input.cwd}: ${remoteNamesResult.stderr.trim()}. Falling back to an empty remote name list.`,
1719	currentPath = exists ? candidatePath : null;	1710	);
1720	} else if (line.startsWith("branch refs/heads/") && currentPath) {	1711	}
1721	worktreeMap.set(line.slice("branch refs/heads/".length), currentPath);	1712
1722	} else if (line === "") {	1713	const defaultBranch =
1723	currentPath = null;	1714	defaultRef.code === 0
		1715	? defaultRef.stdout.trim().replace(/^refs\/remotes\/origin\//, "")
		1716	: null;
		1717
		1718	const worktreeMap = new Map<string, string>();
		1719	if (worktreeList.code === 0) {
		1720	let currentPath: string \| null = null;
		1721	for (const line of worktreeList.stdout.split("\n")) {
		1722	if (line.startsWith("worktree ")) {
		1723	const candidatePath = line.slice("worktree ".length);
		1724	const exists = yield* fileSystem.stat(candidatePath).pipe(
		1725	Effect.map(() => true),
		1726	Effect.catch(() => Effect.succeed(false)),
		1727	);
		1728	currentPath = exists ? candidatePath : null;
		1729	} else if (line.startsWith("branch refs/heads/") && currentPath) {
		1730	worktreeMap.set(line.slice("branch refs/heads/".length), currentPath);
		1731	} else if (line === "") {
		1732	currentPath = null;
		1733	}
1724	}	1734	}
1725	}	1735	}
1726	}
1727		1736
1728	const localBranches = localBranchResult.stdout	1737	const localBranches = localBranchResult.stdout
1729	.split("\n")	1738	.split("\n")
1730	.map(parseBranchLine)	1739	.map(parseBranchLine)
1731	.filter((branch): branch is { name: string; current: boolean } => branch !== null)	1740	.filter((branch): branch is { name: string; current: boolean } => branch !== null)
1732	.map((branch) => ({	1741	.map((branch) => ({
1733	name: branch.name,	1742	name: branch.name,
1734	current: branch.current,	1743	current: branch.current,
1735	isRemote: false,	1744	isRemote: false,
1736	isDefault: branch.name === defaultBranch,	1745	isDefault: branch.name === defaultBranch,
1737	worktreePath: worktreeMap.get(branch.name) ?? null,	1746	worktreePath: worktreeMap.get(branch.name) ?? null,
1738	}))	1747	}))
1739	.toSorted((a, b) => {	1748	.toSorted((a, b) => {
1740	const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;	1749	const aPriority = a.current ? 0 : a.isDefault ? 1 : 2;
1741	const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;	1750	const bPriority = b.current ? 0 : b.isDefault ? 1 : 2;
1742	if (aPriority !== bPriority) return aPriority - bPriority;	1751	if (aPriority !== bPriority) return aPriority - bPriority;
1743		1752
1744	const aLastCommit = branchLastCommit.get(a.name) ?? 0;	1753	const aLastCommit = branchLastCommit.get(a.name) ?? 0;
1745	const bLastCommit = branchLastCommit.get(b.name) ?? 0;	1754	const bLastCommit = branchLastCommit.get(b.name) ?? 0;
1746	if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;	1755	if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
1747	return a.name.localeCompare(b.name);	1756	return a.name.localeCompare(b.name);
1748	});	1757	});
1749		1758
1750	const remoteBranches =	1759	const remoteBranches =
1751	remoteBranchResult.code === 0	1760	remoteBranchResult.code === 0
1752	? remoteBranchResult.stdout	1761	? remoteBranchResult.stdout
1753	.split("\n")	1762	.split("\n")
1754	.map(parseBranchLine)	1763	.map(parseBranchLine)
1755	.filter((branch): branch is { name: string; current: boolean } => branch !== null)	1764	.filter((branch): branch is { name: string; current: boolean } => branch !== null)
1756	.map((branch) => {	1765	.map((branch) => {
1757	const parsedRemoteRef = parseRemoteRefWithRemoteNames(branch.name, remoteNames);	1766	const parsedRemoteRef = parseRemoteRefWithRemoteNames(branch.name, remoteNames);
1758	const remoteBranch: {	1767	const remoteBranch: {
1759	name: string;	1768	name: string;
1760	current: boolean;	1769	current: boolean;
1761	isRemote: boolean;	1770	isRemote: boolean;
1762	remoteName?: string;	1771	remoteName?: string;
1763	isDefault: boolean;	1772	isDefault: boolean;
1764	worktreePath: string \| null;	1773	worktreePath: string \| null;
1765	} = {	1774	} = {
1766	name: branch.name,	1775	name: branch.name,
1767	current: false,	1776	current: false,
1768	isRemote: true,	1777	isRemote: true,
1769	isDefault: false,	1778	isDefault: false,
1770	worktreePath: null,	1779	worktreePath: null,
1771	};	1780	};
1772	if (parsedRemoteRef) {	1781	if (parsedRemoteRef) {
1773	remoteBranch.remoteName = parsedRemoteRef.remoteName;	1782	remoteBranch.remoteName = parsedRemoteRef.remoteName;
1774	}	1783	}
1775	return remoteBranch;	1784	return remoteBranch;
1776	})	1785	})
1777	.toSorted((a, b) => {	1786	.toSorted((a, b) => {
1778	const aLastCommit = branchLastCommit.get(a.name) ?? 0;	1787	const aLastCommit = branchLastCommit.get(a.name) ?? 0;
1779	const bLastCommit = branchLastCommit.get(b.name) ?? 0;	1788	const bLastCommit = branchLastCommit.get(b.name) ?? 0;
1780	if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;	1789	if (aLastCommit !== bLastCommit) return bLastCommit - aLastCommit;
1781	return a.name.localeCompare(b.name);	1790	return a.name.localeCompare(b.name);
1782	})	1791	})
1783	: [];	1792	: [];
1784		1793
1785	const branches = paginateBranches({	1794	const branches = paginateBranches({
1786	branches: filterBranchesForListQuery(	1795	branches: filterBranchesForListQuery(
1787	dedupeRemoteBranchesWithLocalMatches([...localBranches, ...remoteBranches]),	1796	dedupeRemoteBranchesWithLocalMatches([...localBranches, ...remoteBranches]),
1788	input.query,	1797	input.query,
1789	),	1798	),
1790	cursor: input.cursor,	1799	cursor: input.cursor,
1791	limit: input.limit,	1800	limit: input.limit,
1792	});	1801	});
1793		1802
1794	return {	1803	return {
1795	branches: [...branches.branches],	1804	branches: [...branches.branches],
1796	isRepo: true,	1805	isRepo: true,
1797	hasOriginRemote: remoteNames.includes("origin"),	1806	hasOriginRemote: remoteNames.includes("origin"),
1798	nextCursor: branches.nextCursor,	1807	nextCursor: branches.nextCursor,
1799	totalCount: branches.totalCount,	1808	totalCount: branches.totalCount,
1800	};	1809	};
1801	});	1810	},
		1811	);
1802		1812
1803	const createWorktree: GitCoreShape["createWorktree"] = Effect.fn("createWorktree")(	1813	const createWorktree: GitVcsDriverShape["createWorktree"] = Effect.fn("createWorktree")(
1804	function* (input) {	1814	function* (input) {
1805	const targetBranch = input.newBranch ?? input.branch;	1815	const targetBranch = input.newBranch ?? input.branch;
1806	const sanitizedBranch = targetBranch.replace(/\//g, "-");	1816	const sanitizedBranch = targetBranch.replace(/\//g, "-");
@@ -1810,7 +1820,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 3 unmodified lines
1810	? ["worktree", "add", "-b", input.newBranch, worktreePath, input.branch]	1820	? ["worktree", "add", "-b", input.newBranch, worktreePath, input.branch]
1811	: ["worktree", "add", worktreePath, input.branch];	1821	: ["worktree", "add", worktreePath, input.branch];
1812		1822
1813	yield* executeGit("GitCore.createWorktree", input.cwd, args, {	1823	yield* executeGit("GitVcsDriver.createWorktree", input.cwd, args, {
1814	fallbackErrorMessage: "git worktree add failed",	1824	fallbackErrorMessage: "git worktree add failed",
1815	});	1825	});
1816		1826
@@ -1823,12 +1833,12 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 6 unmodified lines
1823	},	1833	},
1824	);	1834	);
1825		1835
1826	const fetchPullRequestBranch: GitCoreShape["fetchPullRequestBranch"] = Effect.fn(	1836	const fetchPullRequestBranch: GitVcsDriverShape["fetchPullRequestBranch"] = Effect.fn(
1827	"fetchPullRequestBranch",	1837	"fetchPullRequestBranch",
1828	)(function* (input) {	1838	)(function* (input) {
1829	const remoteName = yield* resolvePrimaryRemoteName(input.cwd);	1839	const remoteName = yield* resolvePrimaryRemoteName(input.cwd);
1830	yield* executeGit(	1840	yield* executeGit(
1831	"GitCore.fetchPullRequestBranch",	1841	"GitVcsDriver.fetchPullRequestBranch",
1832	input.cwd,	1842	input.cwd,
1833	[	1843	[
1834	"fetch",	1844	"fetch",
@@ -1843,9 +1853,9 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 8 unmodified lines
1843	);	1853	);
1844	});	1854	});
1845		1855
1846	const fetchRemoteBranch: GitCoreShape["fetchRemoteBranch"] = Effect.fn("fetchRemoteBranch")(	1856	const fetchRemoteBranch: GitVcsDriverShape["fetchRemoteBranch"] = Effect.fn("fetchRemoteBranch")(
1847	function* (input) {	1857	function* (input) {
1848	yield* runGit("GitCore.fetchRemoteBranch.fetch", input.cwd, [	1858	yield* runGit("GitVcsDriver.fetchRemoteBranch.fetch", input.cwd, [
1849	"fetch",	1859	"fetch",
1850	"--quiet",	1860	"--quiet",
1851	"--no-tags",	1861	"--no-tags",
@@ -1856,7 +1866,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 4 unmodified lines
1856	const localBranchAlreadyExists = yield* branchExists(input.cwd, input.localBranch);	1866	const localBranchAlreadyExists = yield* branchExists(input.cwd, input.localBranch);
1857	const targetRef = `${input.remoteName}/${input.remoteBranch}`;	1867	const targetRef = `${input.remoteName}/${input.remoteBranch}`;
1858	yield* runGit(	1868	yield* runGit(
1859	"GitCore.fetchRemoteBranch.materialize",	1869	"GitVcsDriver.fetchRemoteBranch.materialize",
1860	input.cwd,	1870	input.cwd,
1861	localBranchAlreadyExists	1871	localBranchAlreadyExists
1862	? ["branch", "--force", input.localBranch, targetRef]	1872	? ["branch", "--force", input.localBranch, targetRef]
@@ -1865,28 +1875,28 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
1865	},	1875	},
1866	);	1876	);
1867		1877
1868	const setBranchUpstream: GitCoreShape["setBranchUpstream"] = (input) =>	1878	const setBranchUpstream: GitVcsDriverShape["setBranchUpstream"] = (input) =>
1869	runGit("GitCore.setBranchUpstream", input.cwd, [	1879	runGit("GitVcsDriver.setBranchUpstream", input.cwd, [
1870	"branch",	1880	"branch",
1871	"--set-upstream-to",	1881	"--set-upstream-to",
1872	`${input.remoteName}/${input.remoteBranch}`,	1882	`${input.remoteName}/${input.remoteBranch}`,
1873	input.branch,	1883	input.branch,
1874	]);	1884	]);
1875		1885
1876	const removeWorktree: GitCoreShape["removeWorktree"] = Effect.fn("removeWorktree")(	1886	const removeWorktree: GitVcsDriverShape["removeWorktree"] = Effect.fn("removeWorktree")(
1877	function* (input) {	1887	function* (input) {
1878	const args = ["worktree", "remove"];	1888	const args = ["worktree", "remove"];
1879	if (input.force) {	1889	if (input.force) {
1880	args.push("--force");	1890	args.push("--force");
1881	}	1891	}
1882	args.push(input.path);	1892	args.push(input.path);
1883	yield* executeGit("GitCore.removeWorktree", input.cwd, args, {	1893	yield* executeGit("GitVcsDriver.removeWorktree", input.cwd, args, {
1884	timeoutMs: 15_000,	1894	timeoutMs: 15_000,
1885	fallbackErrorMessage: "git worktree remove failed",	1895	fallbackErrorMessage: "git worktree remove failed",
1886	}).pipe(	1896	}).pipe(
1887	Effect.mapError((error) =>	1897	Effect.mapError((error) =>
1888	createGitCommandError(	1898	createGitCommandError(
1889	"GitCore.removeWorktree",	1899	"GitVcsDriver.removeWorktree",
1890	input.cwd,	1900	input.cwd,
1891	args,	1901	args,
1892	`${commandLabel(args)} failed (cwd: ${input.cwd}): ${error.message}`,	1902	`${commandLabel(args)} failed (cwd: ${input.cwd}): ${error.message}`,
@@ -1897,31 +1907,33 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 4 unmodified lines
1897	},	1907	},
1898	);	1908	);
1899		1909
1900	const renameBranch: GitCoreShape["renameBranch"] = Effect.fn("renameBranch")(function* (input) {	1910	const renameBranch: GitVcsDriverShape["renameBranch"] = Effect.fn("renameBranch")(
1901	if (input.oldBranch === input.newBranch) {	1911	function* (input) {
1902	return { branch: input.newBranch };	1912	if (input.oldBranch === input.newBranch) {
1903	}	1913	return { branch: input.newBranch };
1904	const targetBranch = yield* resolveAvailableBranchName(input.cwd, input.newBranch);	1914	}
		1915	const targetBranch = yield* resolveAvailableBranchName(input.cwd, input.newBranch);
1905		1916
1906	yield* executeGit(	1917	yield* executeGit(
1907	"GitCore.renameBranch",	1918	"GitVcsDriver.renameBranch",
1908	input.cwd,	1919	input.cwd,
1909	["branch", "-m", "--", input.oldBranch, targetBranch],	1920	["branch", "-m", "--", input.oldBranch, targetBranch],
1910	{	1921	{
1911	timeoutMs: 10_000,	1922	timeoutMs: 10_000,
1912	fallbackErrorMessage: "git branch rename failed",	1923	fallbackErrorMessage: "git branch rename failed",
1913	},	1924	},
1914	);	1925	);
1915		1926
1916	return { branch: targetBranch };	1927	return { branch: targetBranch };
1917	});	1928	},
		1929	);
1918		1930
1919	const checkoutBranch: GitCoreShape["checkoutBranch"] = Effect.fn("checkoutBranch")(	1931	const checkoutBranch: GitVcsDriverShape["checkoutBranch"] = Effect.fn("checkoutBranch")(
1920	function* (input) {	1932	function* (input) {
1921	const [localInputExists, remoteExists] = yield* Effect.all(	1933	const [localInputExists, remoteExists] = yield* Effect.all(
1922	[	1934	[
1923	executeGit(	1935	executeGit(
1924	"GitCore.checkoutBranch.localInputExists",	1936	"GitVcsDriver.checkoutBranch.localInputExists",
1925	input.cwd,	1937	input.cwd,
1926	["show-ref", "--verify", "--quiet", `refs/heads/${input.branch}`],	1938	["show-ref", "--verify", "--quiet", `refs/heads/${input.branch}`],
1927	{	1939	{
@@ -1930,7 +1942,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
1930	},	1942	},
1931	).pipe(Effect.map((result) => result.code === 0)),	1943	).pipe(Effect.map((result) => result.code === 0)),
1932	executeGit(	1944	executeGit(
1933	"GitCore.checkoutBranch.remoteExists",	1945	"GitVcsDriver.checkoutBranch.remoteExists",
1934	input.cwd,	1946	input.cwd,
1935	["show-ref", "--verify", "--quiet", `refs/remotes/${input.branch}`],	1947	["show-ref", "--verify", "--quiet", `refs/remotes/${input.branch}`],
1936	{	1948	{
@@ -1944,7 +1956,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 7 unmodified lines
1944		1956
1945	const localTrackingBranch = remoteExists	1957	const localTrackingBranch = remoteExists
1946	? yield* executeGit(	1958	? yield* executeGit(
1947	"GitCore.checkoutBranch.localTrackingBranch",	1959	"GitVcsDriver.checkoutBranch.localTrackingBranch",
1948	input.cwd,	1960	input.cwd,
1949	["for-each-ref", "--format=%(refname:short)\t%(upstream:short)", "refs/heads"],	1961	["for-each-ref", "--format=%(refname:short)\t%(upstream:short)", "refs/heads"],
1950	{	1962	{
@@ -1964,7 +1976,7 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 13 unmodified lines
1964	const localTrackedBranchTargetExists =	1976	const localTrackedBranchTargetExists =
1965	remoteExists && localTrackedBranchCandidate	1977	remoteExists && localTrackedBranchCandidate
1966	? yield* executeGit(	1978	? yield* executeGit(
1967	"GitCore.checkoutBranch.localTrackedBranchTargetExists",	1979	"GitVcsDriver.checkoutBranch.localTrackedBranchTargetExists",
1968	input.cwd,	1980	input.cwd,
1969	["show-ref", "--verify", "--quiet", `refs/heads/${localTrackedBranchCandidate}`],	1981	["show-ref", "--verify", "--quiet", `refs/heads/${localTrackedBranchCandidate}`],
1970	{	1982	{
@@ -1984,12 +1996,12 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 13 unmodified lines
1984	? ["checkout", localTrackingBranch]	1996	? ["checkout", localTrackingBranch]
1985	: ["checkout", input.branch];	1997	: ["checkout", input.branch];
1986		1998
1987	yield* executeGit("GitCore.checkoutBranch.checkout", input.cwd, checkoutArgs, {	1999	yield* executeGit("GitVcsDriver.checkoutBranch.checkout", input.cwd, checkoutArgs, {
1988	timeoutMs: 10_000,	2000	timeoutMs: 10_000,
1989	fallbackErrorMessage: "git checkout failed",	2001	fallbackErrorMessage: "git checkout failed",
1990	});	2002	});
1991		2003
1992	const branch = yield* runGitStdout("GitCore.checkoutBranch.currentBranch", input.cwd, [	2004	const branch = yield* runGitStdout("GitVcsDriver.checkoutBranch.currentBranch", input.cwd, [
1993	"branch",	2005	"branch",
1994	"--show-current",	2006	"--show-current",
1995	]).pipe(Effect.map((stdout) => stdout.trim() \|\| null));	2007	]).pipe(Effect.map((stdout) => stdout.trim() \|\| null));
@@ -1998,26 +2010,28 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 2 unmodified lines
1998	},	2010	},
1999	);	2011	);
2000		2012
2001	const createBranch: GitCoreShape["createBranch"] = Effect.fn("createBranch")(function* (input) {	2013	const createBranch: GitVcsDriverShape["createBranch"] = Effect.fn("createBranch")(
2002	yield* executeGit("GitCore.createBranch", input.cwd, ["branch", input.branch], {	2014	function* (input) {
2003	timeoutMs: 10_000,	2015	yield* executeGit("GitVcsDriver.createBranch", input.cwd, ["branch", input.branch], {
2004	fallbackErrorMessage: "git branch create failed",	2016	timeoutMs: 10_000,
2005	});	2017	fallbackErrorMessage: "git branch create failed",
2006	if (input.checkout) {	2018	});
2007	yield* checkoutBranch({ cwd: input.cwd, branch: input.branch });	2019	if (input.checkout) {
2008	}	2020	yield* checkoutBranch({ cwd: input.cwd, branch: input.branch });
		2021	}
2009		2022
2010	return { branch: input.branch };	2023	return { branch: input.branch };
2011	});	2024	},
		2025	);
2012		2026
2013	const initRepo: GitCoreShape["initRepo"] = (input) =>	2027	const initRepo: GitVcsDriverShape["initRepo"] = (input) =>
2014	executeGit("GitCore.initRepo", input.cwd, ["init"], {	2028	executeGit("GitVcsDriver.initRepo", input.cwd, ["init"], {
2015	timeoutMs: 10_000,	2029	timeoutMs: 10_000,
2016	fallbackErrorMessage: "git init failed",	2030	fallbackErrorMessage: "git init failed",
2017	}).pipe(Effect.asVoid);	2031	}).pipe(Effect.asVoid);
2018		2032
2019	const listLocalBranchNames: GitCoreShape["listLocalBranchNames"] = (cwd) =>	2033	const listLocalBranchNames: GitVcsDriverShape["listLocalBranchNames"] = (cwd) =>
2020	runGitStdout("GitCore.listLocalBranchNames", cwd, [	2034	runGitStdout("GitVcsDriver.listLocalBranchNames", cwd, [
2021	"branch",	2035	"branch",
2022	"--list",	2036	"--list",
2023	"--no-column",	2037	"--no-column",
@@ -2054,7 +2068,5 @@ export const makeGitCore = Effect.fn("makeGitCore")(function* (options?: { · 30 unmodified lines
2054	checkoutBranch,	2068	checkoutBranch,
2055	initRepo,	2069	initRepo,
2056	listLocalBranchNames,	2070	listLocalBranchNames,
2057	} satisfies GitCoreShape;	2071	} satisfies GitVcsDriverShape;
2058	});	2072	});
2059
2060	export const GitCoreLive = Layer.effect(GitCore, makeGitCore());