@markjaquith/agency 2.56.1 → 2.57.0

package/src/services/RepositoryService.ts

@@ -171,9 +171,12 @@ const inspectRemote = (path: string) =>
 		return result.exitCode === 0 ? result.stdout.trim() : null
 	})
 
-const portableRemote = (path: string) =>
+const portableRemote = (path: string, backend?: VersionControlBackend) =>
 	Effect.gen(function* () {
-		const remote = yield* inspectRemote(path)
+		const backendRemote = backend
+			? yield* backend.remoteUrl(path, "origin")
+			: null
+		const remote = backendRemote ?? (yield* inspectRemote(path))
 		if (!remote) {
 			return yield* new RepositoryError({
 				message: `Repository '${path}' has no portable origin remote`,
@@ -219,7 +222,7 @@ const removalBlockers = (
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const graph = yield* GraphService
-		const report = yield* graph.get({ cwd: startPath })
+		const report = yield* graph.get({ cwd: startPath, backend })
 		const repositoryId = `repository:${repository.alias}`
 		const references = report.edges
 			.filter(
@@ -373,50 +376,30 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						: resolve(startPath, remote)
 					const declaredRemote = inputIsPortable
 						? yield* validateRemote(remote)
-						: yield* portableRemote(cloneSource)
+						: yield* portableRemote(cloneSource, backend)
 					const staging = join(
 						state.root,
 						"repos",
 						`.agency-clone-${validAlias}-${process.pid}-${Date.now()}`,
 					)
 					yield* fs.createDirectory(join(state.root, "repos"))
-					const cloned = yield* fs.runCommand(
-						[
-							"git",
-							"clone",
-							...(backend.kind === "git" ? ["--bare"] : []),
-							"--",
-							cloneSource,
-							staging,
-						],
-						{ captureOutput: true },
+					yield* backend.cloneRepository(cloneSource, staging).pipe(
+						Effect.catchAll((cause) =>
+							fs.deleteDirectory(staging).pipe(
+								Effect.ignore,
+								Effect.zipRight(
+									Effect.fail(
+										new RepositoryError({
+											message: `Failed to clone repository '${remote}': ${cause instanceof Error ? cause.message : String(cause)}`,
+											cause,
+										}),
+									),
+								),
+							),
+						),
 					)
-					if (cloned.exitCode !== 0) {
-						yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
-						return yield* new RepositoryError({
-							message: `Failed to clone repository '${remote}': ${cloned.stderr.trim()}`,
-						})
-					}
-					yield* backend.initializeRepository(staging)
 					if (declaredRemote !== remote) {
-						const setRemote = yield* fs.runCommand(
-							[
-								"git",
-								"-C",
-								staging,
-								"remote",
-								"set-url",
-								"origin",
-								declaredRemote,
-							],
-							{ captureOutput: true },
-						)
-						if (setRemote.exitCode !== 0) {
-							yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
-							return yield* new RepositoryError({
-								message: `Failed to record portable remote for repository '${validAlias}': ${setRemote.stderr.trim()}`,
-							})
-						}
+						yield* backend.setRemoteUrl(staging, "origin", declaredRemote)
 					}
 					const config = withDeclarations(state.config, {
 						...(state.config.repositories ?? {}),
@@ -465,19 +448,21 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							message: `Repository path does not exist: ${resolvedTarget}`,
 						})
 					}
-					const git = yield* fs.runCommand(
-						["git", "-C", resolvedTarget, "rev-parse", "--git-dir"],
-						{ captureOutput: true },
-					)
-					if (git.exitCode !== 0) {
+					const inspection = yield* backend.inspectRepository(resolvedTarget)
+					if (!inspection && backend.kind === "git") {
 						return yield* new RepositoryError({
-							message: `Path is not a Git repository: ${resolvedTarget}`,
+							message: `Path is not a ${backend.kind} repository: ${resolvedTarget}`,
 						})
 					}
 					yield* backend.initializeRepository(resolvedTarget)
+					if (!(yield* backend.inspectRepository(resolvedTarget))) {
+						return yield* new RepositoryError({
+							message: `Path is not a ${backend.kind} repository: ${resolvedTarget}`,
+						})
+					}
 					const declaredRemote =
 						state.config.repositories?.[validAlias]?.remote ??
-						(yield* portableRemote(resolvedTarget))
+						(yield* portableRemote(resolvedTarget, backend))
 					const staging = join(
 						state.root,
 						"repos",
@@ -522,6 +507,8 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const { root, config } = yield* WorkbaseService.pipe(
 						Effect.flatMap((service) => service.loadConfig(startPath)),
 					)
+					const versionControl = yield* VersionControlService
+					const backend = yield* versionControl.forWorkbase(root)
 					const reposPath = join(root, "repos")
 					const entries = (yield* fs.isDirectory(reposPath))
 						? (yield* fs.readDirectory(reposPath)).filter(
@@ -569,20 +556,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						const target = entry.isSymlink
 							? yield* fs.readSymlinkTarget(path)
 							: null
-						const git = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--git-dir"],
-							{ captureOutput: true },
-						)
-						const bare = yield* fs.runCommand(
-							["git", "-C", path, "rev-parse", "--is-bare-repository"],
-							{ captureOutput: true },
-						)
-						const remote =
-							git.exitCode === 0 ? yield* inspectRemote(path) : null
+						const inspection = yield* backend.inspectRepository(path)
+						const remote = inspection?.remote ?? null
 						const states: RepositoryState[] = []
 						if (declaredRemote) states.push("declared")
 						states.push(entry.isSymlink ? "linked" : "materialized")
-						if (git.exitCode !== 0) states.push("invalid")
+						if (!inspection) states.push("invalid")
 						if (declaredRemote && remote !== declaredRemote)
 							states.push("remote-drifted")
 						repositories.push({
@@ -590,9 +569,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							path,
 							kind: entry.isSymlink
 								? "symlink"
-								: bare.stdout.trim() === "true"
-									? "bare"
-									: "repository",
+								: (inspection?.kind ?? "repository"),
 							remote,
 							declaredRemote,
 							target,
@@ -760,10 +737,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath)
 					if (remote === undefined) return repository
 					const portable = yield* validateRemote(remote)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const config = withDeclarations(state.config, {
 						...(state.config.repositories ?? {}),
 						[repository.alias]: { remote: portable },
@@ -777,30 +756,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						const previous = repository.remote
 						const update = (value: string | null) =>
 							Effect.runPromise(
-								fs.runCommand(
-									value === null
-										? [
-												"git",
-												"-C",
-												repository.path,
-												"remote",
-												"remove",
-												"origin",
-											]
-										: [
-												"git",
-												"-C",
-												repository.path,
-												"remote",
-												previous === null ? "add" : "set-url",
-												"origin",
-												value,
-											],
-									{ captureOutput: true },
-								),
-							).then((result) => {
-								if (result.exitCode !== 0) throw new Error(result.stderr.trim())
-							})
+								backend
+									.setRemoteUrl(repository.path, "origin", value)
+									.pipe(
+										Effect.provideService(FileSystemService, fs),
+									) as Effect.Effect<void, unknown, never>,
+							)
 						steps.push({
 							label: `update origin for repos/${repository.alias}`,
 							preflight: async () => {
@@ -810,21 +771,11 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 										`Repository alias '${repository.alias}' changed to a linked checkout; retry the remote update`,
 									)
 								}
-								const current = await Effect.runPromise(
-									fs.runCommand(
-										[
-											"git",
-											"-C",
-											repository.path,
-											"remote",
-											"get-url",
-											"origin",
-										],
-										{ captureOutput: true },
-									),
+								const currentRemote = await Effect.runPromise(
+									backend
+										.remoteUrl(repository.path, "origin")
+										.pipe(Effect.provideService(FileSystemService, fs)),
 								)
-								const currentRemote =
-									current.exitCode === 0 ? current.stdout.trim() : null
 								if (currentRemote !== previous) {
 									throw new Error(
 										`Origin for repository '${repository.alias}' changed; retry the remote update`,
@@ -847,7 +798,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					if (repository.states.includes("missing"))
 						issues.push("Local materialization is missing")
 					if (repository.states.includes("invalid"))
-						issues.push("Path is not a Git repository")
+						issues.push("Path is not a valid repository")
 					if (!repository.declaredRemote)
 						issues.push("Portable remote is not declared")
 					if (repository.states.includes("remote-drifted"))
@@ -877,7 +828,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							unresolved.push({
 								alias: repository.alias,
 								state: "invalid",
-								message: `Local path for '${repository.alias}' is not a valid Git repository`,
+								message: `Local path for '${repository.alias}' is not a valid repository`,
 								action: `Repair the path or run 'agency repo remove ${repository.alias}' before setup`,
 							})
 							continue
@@ -936,25 +887,17 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 								`.agency-setup-${action.alias}-${process.pid}-${Date.now()}`,
 							)
 							yield* fs.createDirectory(join(state.root, "repos"))
-							const cloned = yield* fs.runCommand(
-								[
-									"git",
-									"clone",
-									...(backend.kind === "git" ? ["--bare"] : []),
-									"--",
-									action.remote,
-									from,
-								],
-								{ captureOutput: true },
-							)
-							if (cloned.exitCode !== 0) {
+							const cloned = yield* backend
+								.cloneRepository(action.remote, from)
+								.pipe(Effect.either)
+							if (Either.isLeft(cloned)) {
 								for (const item of staging)
 									yield* fs.deleteDirectory(item.from).pipe(Effect.ignore)
 								return yield* new RepositoryError({
-									message: `Failed to materialize repository '${action.alias}': ${cloned.stderr.trim()}`,
+									message: `Failed to materialize repository '${action.alias}': ${cloned.left instanceof Error ? cloned.left.message : String(cloned.left)}`,
+									cause: cloned.left,
 								})
 							}
-							yield* backend.initializeRepository(from)
 							staging.push({
 								alias: action.alias,
 								from,

package/src/services/ReviewService.test.ts

@@ -166,11 +166,11 @@ describe("ReviewService", () => {
 		if (!Bun.which("jj")) return
 		const repository = join(root, "repos/agency")
 		await rm(repository, { recursive: true, force: true })
-		await git(["clone", source, repository])
 		await git(["switch", "-c", "jj-review"], source)
 		await Bun.write(join(source, "README.md"), "jj review one\n")
 		await git(["commit", "-am", "jj review one"], source)
-		await jj(["git", "init", "--colocate", repository])
+		await jj(["git", "clone", "--no-colocate", source, repository])
+		expect(await Bun.file(join(repository, ".git")).exists()).toBe(false)
 		await Bun.write(
 			join(root, "agency.json"),
 			JSON.stringify({ version: 2, vcs: "jj" }),

package/src/services/ReviewService.ts

@@ -45,8 +45,15 @@ const githubRepository = (remote: string) => {
 const pinRef = (taskId: string) =>
 	`refs/agency/reviews/${Buffer.from(taskId).toString("hex")}`
 
-const runGit = async (args: readonly string[]) => {
-	const child = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+const runGit = async (
+	args: readonly string[],
+	environment: Record<string, string> = {},
+) => {
+	const child = Bun.spawn([...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env: { ...process.env, ...environment },
+	})
 	const [exitCode, stdout, stderr] = await Promise.all([
 		child.exited,
 		new Response(child.stdout).text(),
@@ -121,7 +128,7 @@ const restoreSnapshots = async (
 	}
 }
 
-const normalizeBranch = (input: string, repositoryPath: string) =>
+const normalizeBranch = (input: string) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		if (
@@ -150,7 +157,7 @@ const normalizeBranch = (input: string, repositoryPath: string) =>
 			})
 		}
 		const checked = yield* fs.runCommand(
-			["git", "-C", repositoryPath, "check-ref-format", "--branch", name],
+			["git", "check-ref-format", "--branch", name],
 			{ captureOutput: true },
 		)
 		if (checked.exitCode !== 0) {
@@ -168,6 +175,7 @@ const fetchCommit = (
 ) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
+		const environment = yield* backend.gitEnvironment(repoPath)
 		const temporaryRef = `refs/agency/review-fetch/${process.pid}-${randomUUID()}`
 		const fetched = yield* fs.runCommand(
 			[
@@ -179,12 +187,12 @@ const fetchCommit = (
 				"origin",
 				`+${sourceRef}:${temporaryRef}`,
 			],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		if (fetched.exitCode !== 0) {
 			const cleanup = yield* fs.runCommand(
 				["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-				{ captureOutput: true },
+				{ captureOutput: true, env: environment },
 			)
 			return yield* new ReviewError({
 				message: `Review source '${sourceRef}' could not be fetched: ${fetched.stderr.trim()}${cleanup.exitCode === 0 ? "" : `; temporary ref cleanup failed: ${cleanup.stderr.trim()}`}`,
@@ -199,13 +207,13 @@ const fetchCommit = (
 				"--verify",
 				`${temporaryRef}^{commit}`,
 			],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		const commit = resolved.stdout.trim()
 		if (resolved.exitCode !== 0 || !/^[a-f0-9]{40}$/.test(commit)) {
 			yield* fs.runCommand(
 				["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-				{ captureOutput: true },
+				{ captureOutput: true, env: environment },
 			)
 			return yield* new ReviewError({
 				message: `Review source '${sourceRef}' did not resolve to a commit`,
@@ -214,7 +222,7 @@ const fetchCommit = (
 		const imported = yield* Effect.either(backend.importGitRefs(repoPath))
 		const cleanup = yield* fs.runCommand(
 			["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
-			{ captureOutput: true },
+			{ captureOutput: true, env: environment },
 		)
 		if (cleanup.exitCode !== 0) {
 			return yield* new ReviewError({
@@ -284,7 +292,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							fetchRef: sourceRef,
 						}
 					} else if (input.ref) {
-						sourceRef = yield* normalizeBranch(input.ref, repository.path)
+						sourceRef = yield* normalizeBranch(input.ref)
 						source = { kind: "branch", ref: sourceRef }
 					} else {
 						return yield* new ReviewError({
@@ -366,6 +374,11 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 								task.data.review.repo,
 								root,
 							)
+							const versionControl = yield* VersionControlService
+							const backend = yield* versionControl.forWorkbase(root)
+							const gitEnvironment = yield* backend.gitEnvironment(
+								repository.path,
+							)
 							const hadCheckout = inspection.checkouts.some(
 								(checkout) => checkout.exists || checkout.registered,
 							)
@@ -391,25 +404,31 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							steps.push({
 								label: `advance review pin for ${taskId}`,
 								apply: () =>
-									runGit([
-										"git",
-										"-C",
-										repository.path,
-										"update-ref",
-										pinRef(taskId),
-										latest.commit,
-										previousReview.commit,
-									]).then(() => undefined),
+									runGit(
+										[
+											"git",
+											"-C",
+											repository.path,
+											"update-ref",
+											pinRef(taskId),
+											latest.commit,
+											previousReview.commit,
+										],
+										gitEnvironment,
+									).then(() => undefined),
 								rollback: () =>
-									runGit([
-										"git",
-										"-C",
-										repository.path,
-										"update-ref",
-										pinRef(taskId),
-										previousReview.commit,
-										latest.commit,
-									]).then(() => undefined),
+									runGit(
+										[
+											"git",
+											"-C",
+											repository.path,
+											"update-ref",
+											pinRef(taskId),
+											previousReview.commit,
+											latest.commit,
+										],
+										gitEnvironment,
+									).then(() => undefined),
 								manualRecovery: `Reset ${pinRef(taskId)} to ${previousReview.commit}`,
 							})
 							if (hadCheckout) {

package/src/services/SyncService.test.ts

@@ -59,6 +59,7 @@ describe("SyncService", () => {
 		await Bun.write(
 			gh,
 			`#!/bin/sh
+if [ -n "$GH_CAPTURE" ]; then printf '%s\n' "$@" "GIT_DIR=$GIT_DIR" > "$GH_CAPTURE"; fi
 case "$*" in
 *mergeable*) ;;
 *) echo "mergeable field was not requested" >&2; exit 2 ;;
@@ -82,6 +83,7 @@ JSON
 	afterEach(async () => {
 		if (originalPath === undefined) delete process.env.PATH
 		else process.env.PATH = originalPath
+		delete process.env.GH_CAPTURE
 		await cleanupTempDir(root)
 	})
 
@@ -125,8 +127,14 @@ pr: null
 		if (!Bun.which("jj")) return
 		const repository = join(root, "repos/agency")
 		await rm(repository, { recursive: true, force: true })
-		await git(["clone", join(root, "source"), repository])
-		await jj(["git", "init", "--colocate", repository])
+		await jj([
+			"git",
+			"clone",
+			"--no-colocate",
+			join(root, "source"),
+			repository,
+		])
+		expect(await Bun.file(join(repository, ".git")).exists()).toBe(false)
 		await Bun.write(
 			join(root, "agency.json"),
 			JSON.stringify({ version: 2, vcs: "jj" }),
@@ -147,6 +155,8 @@ pr: null
 				),
 			),
 		)
+		const capture = join(root, "gh-capture")
+		process.env.GH_CAPTURE = capture
 
 		const planned = await runTestEffect(
 			SyncService.pipe(
@@ -160,6 +170,10 @@ pr: null
 				status: "planned",
 			}),
 		)
+		const invocation = await Bun.file(capture).text()
+		expect(invocation).toContain("--repo\n")
+		expect(invocation).toContain("GIT_DIR=")
+		expect(invocation).toContain(".jj")
 
 		const applied = await runTestEffect(
 			SyncService.pipe(
@@ -174,6 +188,7 @@ pr: null
 			branch: "task/jj-sync",
 			dirty: false,
 		})
+		delete process.env.GH_CAPTURE
 	})
 
 	test("observes drift without mutation and applies only safe transitions", async () => {

package/src/services/SyncService.ts

@@ -339,20 +339,34 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 										env: resolved.environment,
 									})
 								} else if (!config.delivery && existing) {
-									result = yield* runExternal([
-										"gh",
-										"pr",
-										"view",
-										existing.url,
-										"--json",
-										"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
-									])
+									const environment = yield* Effect.either(
+										backend.gitEnvironment(repositoryPath),
+									)
+									result = yield* runExternal(
+										[
+											"gh",
+											"pr",
+											"view",
+											existing.url,
+											"--json",
+											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
+										],
+										{
+											cwd: repositoryPath,
+											env: Either.isRight(environment) ? environment.right : {},
+										},
+									)
 								} else if (!config.delivery) {
+									const environment = yield* Effect.either(
+										backend.gitEnvironment(repositoryPath),
+									)
 									result = yield* runExternal(
 										[
 											"gh",
 											"pr",
 											"list",
+											"--repo",
+											remoteRepository,
 											"--head",
 											data.branch,
 											"--state",
@@ -360,7 +374,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 											"--json",
 											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
 										],
-										{ cwd: repositoryPath },
+										{
+											cwd: repositoryPath,
+											env: Either.isRight(environment) ? environment.right : {},
+										},
 									)
 								}
 								return [
@@ -531,14 +548,18 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						let resolvedCommit: string | null = null
 						if ("ref" in checkout) {
 							if (!isCommitId(checkout.ref)) {
-								const remoteRef = yield* runExternal([
-									"git",
-									"-C",
+								const remote = yield* backend.remoteUrl(
 									repositoryPath,
-									"ls-remote",
 									"origin",
-									originRef(checkout.ref),
-								])
+								)
+								const remoteRef = remote
+									? yield* runExternal([
+											"git",
+											"ls-remote",
+											remote,
+											originRef(checkout.ref),
+										])
+									: { exitCode: -1, stdout: "", stderr: "origin unavailable" }
 								resolvedCommit =
 									remoteRef.stdout.match(/^([0-9a-f]{40,64})\s/m)?.[1] ?? null
 								if (!resolvedCommit) {
@@ -998,12 +1019,14 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 					const repositoryPath = join(root, "repos", data.review.repo)
+					const reviewRemote = yield* backend.remoteUrl(
+						repositoryPath,
+						"origin",
+					)
 					const source = yield* runExternal([
 						"git",
-						"-C",
-						repositoryPath,
 						"ls-remote",
-						"origin",
+						reviewRemote ?? "origin",
 						data.review.source.kind === "pull-request"
 							? data.review.source.fetchRef
 							: originRef(data.review.source.ref),

package/src/services/TaskService.ts

@@ -3,6 +3,7 @@ import { Data, Effect, Either } from "effect"
 import { join } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
+import { VersionControlService } from "./VersionControlService"
 import { EpicService, type EpicRecord } from "./EpicService"
 import {
 	EntityId,
@@ -88,11 +89,16 @@ const reviewPinStep = (
 	root: string,
 	taskId: string,
 	review: ReviewRecord,
+	environment: Record<string, string>,
 ): TransactionStep => {
 	const repositoryPath = join(root, "repos", review.repo)
 	const ref = reviewPinRef(taskId)
 	const run = async (args: readonly string[]) => {
-		const child = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
+		const child = Bun.spawn([...args], {
+			stdout: "pipe",
+			stderr: "pipe",
+			env: { ...process.env, ...environment },
+		})
 		const [exitCode, stderr] = await Promise.all([
 			child.exited,
 			new Response(child.stderr).text(),
@@ -132,6 +138,7 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				const fs = yield* FileSystemService
 				const workbase = yield* WorkbaseService
 				const epics = yield* EpicService
+				const versionControl = yield* VersionControlService
 				const root = yield* workbase.discover(startPath)
 				const id = yield* decodeId(input.id)
 				const directory = join(root, "tasks", id)
@@ -257,13 +264,22 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 					const updated = formatMarkdownDocument(epicData, parsed.body)
 					writes.push({ path: parentEpic.path, content: updated })
 				}
+				let reviewEnvironment: Record<string, string> = {}
+				if (input.review) {
+					const backend = yield* versionControl.forWorkbase(root)
+					reviewEnvironment = yield* backend.gitEnvironment(
+						join(root, "repos", input.review.repo),
+					)
+				}
 				yield* runLifecycleTransaction({
 					root,
 					preconditions: parentEpic
 						? [{ path: parentEpic.path, revision: parentEpic.revision }]
 						: [],
 					steps: [
-						...(input.review ? [reviewPinStep(root, id, input.review)] : []),
+						...(input.review
+							? [reviewPinStep(root, id, input.review, reviewEnvironment)]
+							: []),
 						documentWriteStep(root, writes),
 					],
 				})