@markjaquith/agency 3.2.4 → 3.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.2.4",
+  "version": "3.2.6",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/services/PullRequestService.test.ts

@@ -89,16 +89,28 @@ describe("PullRequestService", () => {
 		stdout = "",
 		stderr = "",
 		exitCode = 0,
+		listStdouts = ["[]"],
 	}: {
 		stdout?: string
 		stderr?: string
 		exitCode?: number
+		listStdouts?: readonly string[]
 	}) => {
 		const path = join(root, "bin", "gh")
 		await Bun.write(
 			path,
 			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd() }))
+const args = Bun.argv.slice(2)
+const callFile = Bun.file(${JSON.stringify(ghCallPath)})
+const calls = await callFile.exists() ? await callFile.json() : []
+const listIndex = calls.filter((call) => call.args[1] === "list").length
+calls.push({ args, cwd: process.cwd() })
+await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify(calls))
+if (args[1] === "list") {
+  const responses = ${JSON.stringify(listStdouts)}
+  process.stdout.write(responses[Math.min(listIndex, responses.length - 1)] ?? "[]")
+  process.exit(0)
+}
 process.stdout.write(${JSON.stringify(stdout)})
 process.stderr.write(${JSON.stringify(stderr)})
 process.exit(${exitCode})
@@ -108,10 +120,33 @@ process.exit(${exitCode})
 	}
 
 	const readGhCall = async () =>
+		(
+			(await Bun.file(ghCallPath).json()) as {
+				args: string[]
+				cwd: string
+			}[]
+		).at(-1)!
+
+	const readGhCalls = async () =>
 		(await Bun.file(ghCallPath).json()) as {
 			args: string[]
 			cwd: string
-		}
+		}[]
+
+	const githubRecord = (
+		number: number,
+		branch = "task/example",
+		base = "main",
+	) => ({
+		number,
+		url: `https://github.com/example/agency/pull/${number}`,
+		state: "OPEN",
+		isDraft: false,
+		headRefName: branch,
+		baseRefName: base,
+		headRepository: { nameWithOwner: "example/agency" },
+		mergeable: "UNKNOWN",
+	})
 
 	const expectRemoteBranch = async (branch: string, exists = true) => {
 		const result = await runCommand([
@@ -233,7 +268,17 @@ process.exit(${exitCode})
 		await expectRemoteBranch("task/example")
 		const ghCall = await readGhCall()
 		expect(ghCall).toEqual({
-			args: ["pr", "create", "--fill", "--base", "main"],
+			args: [
+				"pr",
+				"create",
+				"--fill",
+				"--repo",
+				remotePath.replace(/\.git$/, ""),
+				"--base",
+				"main",
+				"--head",
+				"task/example",
+			],
 			cwd: await realpath(join(root, "tasks", "example", "code", "agency")),
 		})
 		const updated = await Bun.file(taskPath).text()
@@ -254,8 +299,12 @@ process.exit(${exitCode})
 			"pr",
 			"create",
 			"--fill",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
 			"--base",
 			"main",
+			"--head",
+			"task/example",
 			"--draft",
 		])
 	})
@@ -279,6 +328,8 @@ process.exit(${exitCode})
 			"--fill",
 			"--title",
 			"Ship the workflow",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
 			"--base",
 			"main",
 			"--head",
@@ -291,6 +342,94 @@ process.exit(${exitCode})
 		])
 	})
 
+	test("records an existing matching GitHub PR without creating another", async () => {
+		await createTask()
+		const existing = githubRecord(46)
+		await writeFakeGh({ listStdouts: [JSON.stringify([existing])] })
+
+		expect(await createPullRequest()).toBe(existing.url)
+		const calls = await readGhCalls()
+		expect(calls).toHaveLength(1)
+		expect(calls[0]!.args).toEqual([
+			"pr",
+			"list",
+			"--repo",
+			remotePath.replace(/\.git$/, ""),
+			"--head",
+			"task/example",
+			"--base",
+			"main",
+			"--state",
+			"all",
+			"--json",
+			"number,state,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeable",
+		])
+	})
+
+	test("recovers a matching GitHub PR after an ambiguous create failure", async () => {
+		await createTask()
+		const recovered = githubRecord(47)
+		await writeFakeGh({
+			stderr: "a pull request already exists",
+			exitCode: 1,
+			listStdouts: ["[]", JSON.stringify([recovered])],
+		})
+
+		expect(await createPullRequest()).toBe(recovered.url)
+		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
+			"list",
+			"create",
+			"list",
+		])
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toMatchObject({
+			url: recovered.url,
+			headBranch: "task/example",
+			baseBranch: "main",
+		})
+	})
+
+	test("recovers a matching GitHub PR after create output is lost", async () => {
+		await createTask()
+		const recovered = githubRecord(48)
+		await writeFakeGh({
+			stdout: "Pull request created successfully",
+			listStdouts: ["[]", JSON.stringify([recovered])],
+		})
+
+		expect(await createPullRequest()).toBe(recovered.url)
+		expect((await readGhCalls()).map((call) => call.args[1])).toEqual([
+			"list",
+			"create",
+			"list",
+		])
+	})
+
+	test("does not adopt a GitHub PR with mismatched refs", async () => {
+		await createTask()
+		await writeFakeGh({
+			stdout: "Pull request created successfully",
+			listStdouts: [
+				JSON.stringify([githubRecord(49, "task/other")]),
+				JSON.stringify([githubRecord(49, "task/other")]),
+			],
+		})
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"GitHub CLI did not return a pull request URL",
+		)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect("pr" in task.data && task.data.pr).toBeNull()
+	})
+
 	test("rejects task-aware head and base values that contradict declarations", async () => {
 		await createTask()
 		await expect(

package/src/services/PullRequestService.ts

@@ -15,12 +15,16 @@ import type { PullRequestRecord } from "../workbase/schemas"
 import {
 	normalizePullRequestRecord,
 	parsePullRequestRecord,
+	recordFromGitHubJson,
 	recordFromGitHubUrl,
 	repositoryFromRemote,
 	resolveDeliveryCommand,
 	resolveGitHubCreateCommand,
 } from "../workbase/delivery-command"
 
+const GITHUB_PR_FIELDS =
+	"number,state,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeable"
+
 class PullRequestError extends Data.TaggedError("PullRequestError")<{
 	readonly message: string
 }> {}
@@ -205,6 +209,84 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						})
 					}
 					const repository = repositoryFromRemote(remoteUrl)
+					const isGitHubRepository = /^[^/]+\/[^/]+$/.test(repository)
+					const discoverGitHubPullRequest = () =>
+						Effect.gen(function* () {
+							const listed = yield* fs.runCommand(
+								[
+									"gh",
+									"pr",
+									"list",
+									"--repo",
+									repository,
+									"--head",
+									execution.branch,
+									"--base",
+									execution.base,
+									"--state",
+									"all",
+									"--json",
+									GITHUB_PR_FIELDS,
+								],
+								{ cwd: workspace.writablePath!, captureOutput: true },
+							)
+							if (listed.exitCode !== 0) {
+								return yield* new PullRequestError({
+									message: `Failed to discover existing pull requests: ${listed.stderr}`,
+								})
+							}
+							const records = yield* Effect.try({
+								try: () => {
+									const parsed: unknown = JSON.parse(listed.stdout)
+									if (!Array.isArray(parsed)) {
+										throw new Error(
+											"GitHub CLI did not return a pull request list",
+										)
+									}
+									return parsed.map((value) =>
+										recordFromGitHubJson(value as Record<string, unknown>),
+									)
+								},
+								catch: (cause) =>
+									new PullRequestError({
+										message:
+											cause instanceof Error ? cause.message : String(cause),
+									}),
+							})
+							const matches = records.filter(
+								(record) =>
+									(!isGitHubRepository ||
+										(record.repository.toLowerCase() ===
+											repository.toLowerCase() &&
+											record.headRepository?.toLowerCase() ===
+												repository.toLowerCase() &&
+											record.baseRepository?.toLowerCase() ===
+												repository.toLowerCase())) &&
+									record.headBranch === execution.branch &&
+									record.baseBranch === execution.base,
+							)
+							if (matches.length > 1) {
+								return yield* new PullRequestError({
+									message: `Multiple pull requests match '${execution.branch}' -> '${execution.base}'`,
+								})
+							}
+							return matches[0] ?? null
+						})
+					const recoverGitHubPullRequest = () =>
+						discoverGitHubPullRequest().pipe(
+							Effect.catchAll(() => Effect.succeed(null)),
+						)
+					if (!config.delivery) {
+						const existing = yield* discoverGitHubPullRequest()
+						if (existing) {
+							return yield* service.setRecord(
+								taskId,
+								phaseId,
+								existing,
+								workspace.root,
+							)
+						}
+					}
 					const resolved = config.delivery
 						? resolveDeliveryCommand(config.delivery, "create", {
 								repository,
@@ -215,10 +297,11 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 								identifier: "",
 							})
 						: resolveGitHubCreateCommand({
+								repository,
 								base: execution.base,
 								draft,
 								title: options.title,
-								head: options.head,
+								head: execution.branch,
 								labels: options.labels,
 							})
 					const created = yield* fs.runCommand(resolved.argv, {
@@ -227,38 +310,79 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						env: resolved.environment,
 					})
 					if (created.exitCode !== 0) {
+						if (!config.delivery) {
+							const recovered = yield* recoverGitHubPullRequest()
+							if (recovered) {
+								return yield* service.setRecord(
+									taskId,
+									phaseId,
+									recovered,
+									workspace.root,
+								)
+							}
+						}
 						return yield* new PullRequestError({
 							message: `Failed to create pull request: ${created.stderr}`,
 						})
 					}
-					const record = yield* Effect.try({
-						try: () => {
-							if (config.delivery) return parsePullRequestRecord(created.stdout)
-							const url = created.stdout.split(/\s+/).find((value) => {
-								try {
-									recordFromGitHubUrl(value)
-									return true
-								} catch {
-									return false
+					const parsedRecord = yield* Effect.either(
+						Effect.try({
+							try: () => {
+								if (config.delivery)
+									return parsePullRequestRecord(created.stdout)
+								const url = created.stdout.split(/\s+/).find((value) => {
+									try {
+										recordFromGitHubUrl(value)
+										return true
+									} catch {
+										return false
+									}
+								})
+								if (!url)
+									throw new Error(
+										"GitHub CLI did not return a pull request URL",
+									)
+								const normalized = normalizePullRequestRecord(url)
+								if (
+									isGitHubRepository &&
+									normalized.repository.toLowerCase() !==
+										repository.toLowerCase()
+								) {
+									throw new Error(
+										"GitHub CLI returned a pull request for the wrong repository",
+									)
 								}
-							})
-							if (!url)
-								throw new Error("GitHub CLI did not return a pull request URL")
-							const normalized = normalizePullRequestRecord(url)
-							return {
-								...normalized,
-								headRepository: repository,
-								headBranch: execution.branch,
-								baseRepository: normalized.repository,
-								baseBranch: execution.base,
-								draft,
+								return {
+									...normalized,
+									headRepository: repository,
+									headBranch: execution.branch,
+									baseRepository: normalized.repository,
+									baseBranch: execution.base,
+									draft,
+								}
+							},
+							catch: (cause) =>
+								new PullRequestError({
+									message:
+										cause instanceof Error ? cause.message : String(cause),
+								}),
+						}),
+					)
+					if (parsedRecord._tag === "Left") {
+						if (!config.delivery) {
+							const recovered = yield* recoverGitHubPullRequest()
+							if (recovered) {
+								return yield* service.setRecord(
+									taskId,
+									phaseId,
+									recovered,
+									workspace.root,
+								)
 							}
-						},
-						catch: (cause) =>
-							new PullRequestError({
-								message: cause instanceof Error ? cause.message : String(cause),
-							}),
-					})
+						}
+						return yield* parsedRecord.left
+					}
+					const record = parsedRecord.right
 					if (
 						config.delivery &&
 						(record.provider !== config.delivery.provider ||

package/src/services/RepositoryService.test.ts

@@ -1,6 +1,6 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir, realpath } from "node:fs/promises"
+import { mkdir, realpath, stat } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { RepositoryService } from "./RepositoryService"
@@ -136,6 +136,30 @@ describe("RepositoryService", () => {
 		})
 	})
 
+	test("inspects only the requested repository alias", async () => {
+		const requested = join(root, "repos/requested")
+		const unrelated = join(root, "repos/unrelated")
+		await mkdir(requested, { recursive: true })
+		await mkdir(unrelated, { recursive: true })
+		await runGit(["init", "--initial-branch=main", requested])
+		await runGit(["init", "--initial-branch=main", unrelated])
+
+		const spawn = spyOn(Bun, "spawn")
+		try {
+			const repository = await runTestEffect(
+				RepositoryService.pipe(
+					Effect.flatMap((service) => service.show("requested", root)),
+				),
+			)
+			expect(repository.alias).toBe("requested")
+			expect(spawn.mock.calls).toHaveLength(1)
+			expect(spawn.mock.calls[0]?.[0]).toContain(requested)
+			expect(spawn.mock.calls[0]?.[0]).not.toContain(unrelated)
+		} finally {
+			spawn.mockRestore()
+		}
+	})
+
 	test("materializes a linked alias without invalidating active worktrees", async () => {
 		const target = join(root, "linked-repository")
 		const checkout = join(root, "tasks/active/code/linked")
@@ -146,6 +170,13 @@ describe("RepositoryService", () => {
 		await Bun.write(join(target, "README.md"), "linked\n")
 		await runGit(["-C", target, "add", "README.md"])
 		await runGit(["-C", target, "commit", "-m", "initial"])
+		const commit = await gitOutput(["-C", target, "rev-parse", "HEAD"])
+		const sourceObject = join(
+			target,
+			".git/objects",
+			commit.slice(0, 2),
+			commit.slice(2),
+		)
 		await setPortableOrigin(target, "materialized")
 		await runTestEffect(
 			RepositoryService.pipe(
@@ -218,6 +249,15 @@ status: working
 				"refs/agency/reviews/active",
 			]),
 		).toBe(await gitOutput(["-C", target, "rev-parse", "main"]))
+		const materializedObject = join(
+			root,
+			"repos/linked/objects",
+			commit.slice(0, 2),
+			commit.slice(2),
+		)
+		expect((await stat(materializedObject)).ino).not.toBe(
+			(await stat(sourceObject)).ino,
+		)
 	})
 
 	test("preserves detached registered worktree commits from a shallow linked repository", async () => {

package/src/services/RepositoryService.ts

@@ -186,18 +186,71 @@ const portableRemote = (path: string, backend?: VersionControlBackend) =>
 		return yield* validateRemote(remote)
 	})
 
-const find = (alias: string, startPath: string) =>
+const inspectRepository = (
+	alias: string,
+	state: Effect.Effect.Success<ReturnType<typeof configState>>,
+	backend: VersionControlBackend,
+) =>
 	Effect.gen(function* () {
-		const service = yield* RepositoryService
-		const validAlias = yield* validateAlias(alias)
-		const repositories = yield* service.list(startPath)
-		const repository = repositories.find((item) => item.alias === validAlias)
-		if (!repository) {
+		const fs = yield* FileSystemService
+		const path = join(state.root, "repos", alias)
+		const declaredRemote = state.config.repositories?.[alias]?.remote ?? null
+		const entry = yield* fs.inspectFile(path)
+		if (entry.kind === "missing") {
+			if (declaredRemote) {
+				return {
+					alias,
+					path,
+					kind: null,
+					remote: null,
+					declaredRemote,
+					target: null,
+					states: ["declared", "missing"],
+				} as RepositoryInfo
+			}
 			return yield* new RepositoryError({
-				message: `Unknown repository alias '${validAlias}'`,
+				message: `Unknown repository alias '${alias}'`,
 			})
 		}
-		return repository
+		const isSymlink = entry.kind === "symlink"
+		if (!isSymlink && !(yield* fs.isDirectory(path))) {
+			return {
+				alias,
+				path,
+				kind: null,
+				remote: null,
+				declaredRemote,
+				target: null,
+				states: [...(declaredRemote ? (["declared"] as const) : []), "invalid"],
+			} as RepositoryInfo
+		}
+		const target = isSymlink ? yield* fs.readSymlinkTarget(path) : null
+		const inspection = yield* backend.inspectRepository(path)
+		const remote = inspection?.remote ?? null
+		const states: RepositoryState[] = []
+		if (declaredRemote) states.push("declared")
+		states.push(isSymlink ? "linked" : "materialized")
+		if (!inspection) states.push("invalid")
+		if (declaredRemote && remote !== declaredRemote)
+			states.push("remote-drifted")
+		return {
+			alias,
+			path,
+			kind: isSymlink ? "symlink" : (inspection?.kind ?? "repository"),
+			remote,
+			declaredRemote,
+			target,
+			states,
+		} as RepositoryInfo
+	})
+
+const find = (alias: string, startPath: string) =>
+	Effect.gen(function* () {
+		const versionControl = yield* VersionControlService
+		const validAlias = yield* validateAlias(alias)
+		const state = yield* configState(startPath)
+		const backend = yield* versionControl.forWorkbase(state.root)
+		return yield* inspectRepository(validAlias, state, backend)
 	})
 
 const requireMaterialized = (repository: RepositoryInfo) =>
@@ -450,14 +503,11 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const backend = yield* versionControl.forWorkbase(state.root)
 					const destination = join(state.root, "repos", validAlias)
 					const resolvedTarget = resolve(startPath, target)
-					const existing = (yield* RepositoryService)
-						.list(state.root)
-						.pipe(
-							Effect.map((items) =>
-								items.find((item) => item.alias === validAlias),
-							),
-						)
-					const current = yield* existing
+					const current =
+						state.config.repositories?.[validAlias] ||
+						(yield* fs.exists(destination))
+							? yield* inspectRepository(validAlias, state, backend)
+							: undefined
 					const localCurrent =
 						current && !current.states.includes("missing") ? current : undefined
 					if (localCurrent?.kind === "symlink") {
@@ -521,10 +571,17 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
 					const versionControl = yield* VersionControlService
-					const repository = yield* find(alias, startPath)
+					const validAlias = yield* validateAlias(alias)
+					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
+					const repository = yield* inspectRepository(
+						validAlias,
+						state,
+						backend,
+					)
 					if (repository.kind !== "symlink" || !repository.target) {
 						return yield* new RepositoryError({
-							message: `Repository alias '${alias}' is not linked`,
+							message: `Repository alias '${validAlias}' is not linked`,
 						})
 					}
 					if (repository.states.includes("invalid")) {
@@ -543,9 +600,6 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						})
 					}
 
-					const state = yield* configState(startPath)
-					const backend = yield* versionControl.forWorkbase(state.root)
-
 					const source = yield* fs.realPath(repository.path)
 					const registered = yield* backend.listWorkspaces(repository.path)
 					const registeredState = registered
@@ -854,78 +908,22 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 			list: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
-					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 state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
+					const reposPath = join(state.root, "repos")
 					const entries = (yield* fs.isDirectory(reposPath))
 						? (yield* fs.readDirectory(reposPath)).filter(
 								(entry) => !entry.name.startsWith(".agency-"),
 							)
 						: []
-					const local = new Map(entries.map((entry) => [entry.name, entry]))
 					const aliases = new Set([
-						...Object.keys(config.repositories ?? {}),
-						...local.keys(),
+						...Object.keys(state.config.repositories ?? {}),
+						...entries.map((entry) => entry.name),
 					])
 					return yield* Effect.forEach(
 						[...aliases].sort(),
-						(alias) =>
-							Effect.gen(function* () {
-								const path = join(reposPath, alias)
-								const entry = local.get(alias)
-								const declaredRemote =
-									config.repositories?.[alias]?.remote ?? null
-								if (!entry) {
-									return {
-										alias,
-										path,
-										kind: null,
-										remote: null,
-										declaredRemote,
-										target: null,
-										states: ["declared", "missing"] as RepositoryState[],
-									} satisfies RepositoryInfo
-								}
-								if (!entry.isDirectory && !entry.isSymlink) {
-									return {
-										alias,
-										path,
-										kind: null,
-										remote: null,
-										declaredRemote,
-										target: null,
-										states: [
-											...(declaredRemote ? (["declared"] as const) : []),
-											"invalid",
-										] as RepositoryState[],
-									} satisfies RepositoryInfo
-								}
-								const target = entry.isSymlink
-									? yield* fs.readSymlinkTarget(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 (!inspection) states.push("invalid")
-								if (declaredRemote && remote !== declaredRemote)
-									states.push("remote-drifted")
-								return {
-									alias,
-									path,
-									kind: entry.isSymlink
-										? "symlink"
-										: (inspection?.kind ?? "repository"),
-									remote,
-									declaredRemote,
-									target,
-									states,
-								} satisfies RepositoryInfo
-							}),
+						(alias) => inspectRepository(alias, state, backend),
 						{ concurrency: 8 },
 					)
 				}),

package/src/services/VersionControlService.ts

@@ -171,7 +171,15 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 						yield* requireSuccess(
 							"Failed to clone Git repository",
 							fs.runCommand(
-								["git", "clone", "--bare", "--", source, destination],
+								[
+									"git",
+									"clone",
+									"--bare",
+									"--no-hardlinks",
+									"--",
+									source,
+									destination,
+								],
 								{
 									captureOutput: true,
 								},

package/src/workbase/delivery-command.test.ts

@@ -34,24 +34,19 @@ describe("delivery commands", () => {
 
 	test("builds the default GitHub create command", () => {
 		const input = {
+			repository: "example/agency",
 			base: "main",
 			draft: false,
+			head: "feat/example",
 		} as const
 		expect(resolveGitHubCreateCommand(input)).toEqual({
-			argv: ["gh", "pr", "create", "--fill", "--base", "main"],
-			environment: {},
-		})
-		expect(
-			resolveGitHubCreateCommand({
-				...input,
-				head: "feat/example",
-			}),
-		).toEqual({
 			argv: [
 				"gh",
 				"pr",
 				"create",
 				"--fill",
+				"--repo",
+				"example/agency",
 				"--base",
 				"main",
 				"--head",
@@ -74,6 +69,8 @@ describe("delivery commands", () => {
 				"--fill",
 				"--title",
 				"Requested",
+				"--repo",
+				"example/agency",
 				"--base",
 				"main",
 				"--head",

package/src/workbase/delivery-command.ts

@@ -19,16 +19,18 @@ export const repositoryFromRemote = (remote: string) =>
 		.replace(/\/$/, "")
 
 export const resolveGitHubCreateCommand = ({
+	repository,
 	base,
 	draft,
 	title,
 	head,
 	labels = [],
 }: {
+	readonly repository: string
 	readonly base: string
 	readonly draft: boolean
 	readonly title?: string
-	readonly head?: string
+	readonly head: string
 	readonly labels?: readonly string[]
 }) => ({
 	argv: [
@@ -36,9 +38,12 @@ export const resolveGitHubCreateCommand = ({
 		"pr",
 		"create",
 		...(title ? ["--fill", "--title", title] : ["--fill"]),
+		"--repo",
+		repository,
 		"--base",
 		base,
-		...(head ? ["--head", head] : []),
+		"--head",
+		head,
 		...(draft ? ["--draft"] : []),
 		...labels.flatMap((label) => ["--label", label]),
 	],