@markjaquith/agency 2.54.1 → 2.54.3

package/README.md

@@ -857,7 +857,8 @@ including readiness checks and durable PR recording. Other `agency pr`
 invocations forward every argument to `gh pr`. From an execution task or phase
 directory, including descendants, passthrough runs in that execution unit's
 authoritative writable checkout. Otherwise it runs in the caller's current
-directory.
+directory. In jj workbases, Agency also supplies the repository and the work
+item's declared branch to subcommands that would otherwise infer Git context.
 
 ### Status and Validation
 

package/package.json

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

package/src/commands/pr.test.ts

@@ -50,9 +50,19 @@ exit "\${GH_EXIT:-0}"
 	const captured = async () =>
 		(await Bun.file(capturePath).text()).trim().split("\n")
 
-	const createExecutionWorkbase = async () => {
+	const createExecutionWorkbase = async (vcs: "git" | "jj" = "git") => {
 		const root = join(tempRoot, "workbase")
-		await write(root, "agency.json", '{"version":2}\n')
+		await write(
+			root,
+			"agency.json",
+			`${JSON.stringify({
+				version: 2,
+				vcs,
+				repositories: {
+					agency: { remote: "https://github.com/example/agency.git" },
+				},
+			})}\n`,
+		)
 		await mkdir(join(root, "repos/agency"), { recursive: true })
 		await mkdir(join(root, "tasks/single/code/agency"), { recursive: true })
 		await write(
@@ -163,6 +173,51 @@ status: open
 		])
 	})
 
+	test("injects the execution branch and repository for jj targets", async () => {
+		const root = await createExecutionWorkbase("jj")
+		const task = join(root, "tasks/single")
+		const phase = join(root, "tasks/multi/phases/build")
+
+		expect(await runTestEffect(pr(["view", "--web"], task))).toBe(0)
+		expect(await captured()).toEqual([
+			await realpath(join(task, "code/agency")),
+			"pr",
+			"view",
+			"feat/single",
+			"--repo",
+			"example/agency",
+			"--web",
+		])
+
+		expect(
+			await runTestEffect(pr(["create", "--title", "Example"], phase)),
+		).toBe(0)
+		expect(await captured()).toEqual([
+			await realpath(join(phase, "code/agency")),
+			"pr",
+			"create",
+			"--head",
+			"feat/build",
+			"--repo",
+			"example/agency",
+			"--title",
+			"Example",
+		])
+	})
+
+	test("preserves explicit jj PR and repository targets", async () => {
+		const root = await createExecutionWorkbase("jj")
+		const task = join(root, "tasks/single")
+		const args = ["view", "123", "--repo", "other/repository"]
+
+		expect(await runTestEffect(pr(args, task))).toBe(0)
+		expect(await captured()).toEqual([
+			await realpath(join(task, "code/agency")),
+			"pr",
+			...args,
+		])
+	})
+
 	test("falls back to the invocation directory without execution authority", async () => {
 		const root = await createExecutionWorkbase()
 		const orchestration = join(root, "tasks/multi")

package/src/commands/pr.ts

@@ -3,8 +3,10 @@ import { resolve } from "node:path"
 import { ContextService } from "../services/ContextService"
 import { FileSystemService } from "../services/FileSystemService"
 import { PullRequestService } from "../services/PullRequestService"
+import { WorkbaseService } from "../services/WorkbaseService"
 import type { BaseCommandOptions } from "../utils/command"
 import { createLoggers } from "../utils/effect"
+import { repositoryFromRemote } from "../workbase/delivery-command"
 
 interface PrCreateOptions extends BaseCommandOptions {
 	readonly taskId: string
@@ -13,6 +15,56 @@ interface PrCreateOptions extends BaseCommandOptions {
 	readonly force?: boolean
 }
 
+const branchTargetCommands = new Set([
+	"checkout",
+	"checks",
+	"close",
+	"comment",
+	"diff",
+	"edit",
+	"lock",
+	"merge",
+	"ready",
+	"reopen",
+	"revert",
+	"review",
+	"unlock",
+	"update-branch",
+	"view",
+])
+
+const hasOption = (args: readonly string[], short: string, long: string) =>
+	args.some(
+		(argument) =>
+			argument === short ||
+			argument.startsWith(`${short}=`) ||
+			argument === long ||
+			argument.startsWith(`${long}=`),
+	)
+
+const withJjContext = (
+	args: readonly string[],
+	branch: string,
+	repository: string,
+) => {
+	const [command, ...rest] = args
+	if (!command) return args
+
+	const branchArgs =
+		(command === "create" || command === "new") &&
+		!hasOption(rest, "-H", "--head")
+			? ["--head", branch]
+			: branchTargetCommands.has(command) &&
+				  (rest.length === 0 || rest[0]?.startsWith("-"))
+				? [branch]
+				: []
+	const repositoryArgs = hasOption(rest, "-R", "--repo")
+		? []
+		: ["--repo", repository]
+
+	return [command, ...branchArgs, ...repositoryArgs, ...rest]
+}
+
 export const prCreate = (options: PrCreateOptions) =>
 	Effect.gen(function* () {
 		const pullRequests = yield* PullRequestService
@@ -31,6 +83,7 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 	Effect.gen(function* () {
 		const contexts = yield* ContextService
 		const fs = yield* FileSystemService
+		const workbase = yield* WorkbaseService
 		const invocationCwd = resolve(cwd)
 		const context = yield* contexts
 			.get({ cwd: invocationCwd, target: ".", compact: true })
@@ -40,7 +93,26 @@ export const pr = (args: readonly string[], cwd: string = process.cwd()) =>
 				? context.authority.writable?.checkoutPath
 				: null
 		const focusedCwd = writableCheckout ?? invocationCwd
-		const result = yield* fs.runCommand(["gh", "pr", ...args], {
+		let forwardedArgs = args
+		if (
+			writableCheckout &&
+			context?.workbase.vcs === "jj" &&
+			context.authority.writable
+		) {
+			const execution =
+				context.documents?.phase?.data ?? context.documents?.task?.data
+			const { config } = yield* workbase.loadConfig(context.workbase.root)
+			const remote =
+				config.repositories?.[context.authority.writable.repo]?.remote
+			if (execution && "branch" in execution && remote) {
+				forwardedArgs = withJjContext(
+					args,
+					execution.branch,
+					repositoryFromRemote(remote),
+				)
+			}
+		}
+		const result = yield* fs.runCommand(["gh", "pr", ...forwardedArgs], {
 			cwd: focusedCwd,
 			passthrough: true,
 		})
@@ -53,5 +125,6 @@ Usage: agency pr create <task-id> [phase-id] [--draft] [--force] [--json]
 
 Create records a pull request for an Agency execution unit. Other invocations
 run gh pr unchanged, focusing the writable repository checkout when invoked from
-an Agency execution task or phase.
+an Agency execution task or phase. In jj workbases, Agency supplies the declared
+branch and repository to gh subcommands that would otherwise infer Git context.
 `

package/src/services/DoctorService.ts

@@ -10,6 +10,7 @@ import { RepositoryService } from "./RepositoryService"
 import { TaskService } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
 import { WorktreeService } from "./WorktreeService"
+import { VersionControlService } from "./VersionControlService"
 
 type DoctorCheckLevel = "error" | "warning" | "optional"
 
@@ -87,7 +88,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 					const tasks = yield* TaskService
 					const workbases = yield* WorkbaseService
 					const worktrees = yield* WorktreeService
+					const versionControl = yield* VersionControlService
 					const { root, config } = yield* workbases.loadConfig(startPath)
+					const backend = yield* versionControl.forWorkbase(root)
 					const checks: DoctorCheck[] = []
 					const add = (
 						check: Omit<DoctorCheck, "remediation"> & {
@@ -409,32 +412,8 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						}
 
 						for (const ref of [...(refs.get(repository.alias) ?? [])].sort()) {
-							const local = yield* fs.runCommand(
-								[
-									"git",
-									"-C",
-									repository.path,
-									"rev-parse",
-									"--verify",
-									`${ref}^{commit}`,
-								],
-								{ captureOutput: true },
-							)
-							const remote =
-								local.exitCode === 0
-									? local
-									: yield* fs.runCommand(
-											[
-												"git",
-												"-C",
-												repository.path,
-												"rev-parse",
-												"--verify",
-												`origin/${ref}^{commit}`,
-											],
-											{ captureOutput: true },
-										)
-							const found = local.exitCode === 0 || remote.exitCode === 0
+							const found =
+								(yield* backend.resolveRevision(repository.path, ref)) !== null
 							add({
 								id: `ref.${repository.alias}.${ref}`,
 								category: "ref",

package/src/services/PullRequestService.ts

@@ -16,20 +16,15 @@ import {
 	normalizePullRequestRecord,
 	parsePullRequestRecord,
 	recordFromGitHubUrl,
+	repositoryFromRemote,
 	resolveDeliveryCommand,
+	resolveGitHubCreateCommand,
 } from "../workbase/delivery-command"
 
 class PullRequestError extends Data.TaggedError("PullRequestError")<{
 	readonly message: string
 }> {}
 
-const repositoryFromRemote = (remote: string) =>
-	remote
-		.replace(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?[^/]+\//i, "")
-		.replace(/^[^:]+:/, "")
-		.replace(/\.git\/?$/, "")
-		.replace(/\/$/, "")
-
 interface PullRequestOptions extends BaseCommandOptions {
 	readonly force?: boolean
 }
@@ -197,18 +192,13 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 								url: "",
 								identifier: "",
 							})
-						: {
-								argv: [
-									"gh",
-									"pr",
-									"create",
-									"--fill",
-									"--base",
-									execution.base,
-									...(draft ? ["--draft"] : []),
-								],
-								environment: {},
-							}
+						: resolveGitHubCreateCommand({
+								base: execution.base,
+								branch: execution.branch,
+								repository,
+								draft,
+								vcs: config.vcs ?? "git",
+							})
 					const created = yield* fs.runCommand(resolved.argv, {
 						cwd: workspace.writablePath,
 						captureOutput: true,

package/src/services/ReviewService.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
-import { mkdir } from "node:fs/promises"
+import { mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
 import { TaskService } from "./TaskService"
@@ -13,6 +13,7 @@ import { PhaseService } from "./PhaseService"
 import { ArchiveService } from "./ArchiveService"
 import { ClaimService } from "./ClaimService"
 import { SyncService } from "./SyncService"
+import { DoctorService } from "./DoctorService"
 import { task as taskCommand } from "../commands/task"
 
 const git = async (args: string[], cwd?: string) => {
@@ -26,6 +27,16 @@ const git = async (args: string[], cwd?: string) => {
 		throw new Error(await new Response(child.stderr).text())
 }
 
+const jj = async (args: string[]) => {
+	const child = Bun.spawn(["jj", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await child.exited
+	if (child.exitCode !== 0)
+		throw new Error(await new Response(child.stderr).text())
+}
+
 describe("ReviewService", () => {
 	let root: string
 	let source: string
@@ -151,6 +162,78 @@ describe("ReviewService", () => {
 		expect(new TextDecoder().decode(oldPins.stdout).trim()).toBe("")
 	})
 
+	test("imports jj reviews for creation, diagnostics, materialization, and refresh", async () => {
+		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 Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+
+		await runTestEffect(
+			taskCommand({
+				subcommand: "create",
+				args: ["jj-review"],
+				review: "agency",
+				ref: "jj-review",
+				cwd: root,
+				silent: true,
+			}),
+		)
+		const created = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("jj-review", root)),
+			),
+		)
+		const original = "review" in created.data ? created.data.review.commit : ""
+
+		const context = await runTestEffect(
+			ContextService.pipe(
+				Effect.flatMap((service) =>
+					service.get({ target: "jj-review", cwd: root }),
+				),
+			),
+		)
+		expect(context.workspace!.warnings).toEqual([])
+		expect(context.review?.checkout?.resolvedCommit).toBe(original)
+
+		const doctor = await runTestEffect(
+			DoctorService.pipe(Effect.flatMap((service) => service.inspect(root))),
+		)
+		expect(
+			doctor.checks.find((check) => check.id === `ref.agency.${original}`),
+		).toMatchObject({ status: "pass" })
+
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("jj-review", undefined, root),
+				),
+			),
+		)
+		expect(
+			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
+		).toBe("jj review one\n")
+
+		await Bun.write(join(source, "README.md"), "jj review two\n")
+		await git(["commit", "-am", "jj review two"], source)
+		const refreshed = await runTestEffect(
+			ReviewService.pipe(
+				Effect.flatMap((service) => service.refresh("jj-review", root)),
+			),
+		)
+		expect(refreshed.changed).toBe(true)
+		expect(
+			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
+		).toBe("jj review two\n")
+	})
+
 	test("rejects delivery and phase operations even when forced", async () => {
 		await createReview()
 		await expect(

package/src/services/ReviewService.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Layer } from "effect"
+import { Data, Effect, Either, Layer } from "effect"
 import { randomUUID } from "node:crypto"
 import { lstat, mkdir } from "node:fs/promises"
 import { dirname } from "node:path"
@@ -15,6 +15,7 @@ import {
 	GitVersionControlService,
 	JjVersionControlService,
 	VersionControlService,
+	type VersionControlBackend,
 } from "./VersionControlService"
 import { withWorktreeLocks } from "./WorktreeLock"
 import {
@@ -160,7 +161,11 @@ const normalizeBranch = (input: string, repositoryPath: string) =>
 		return `refs/heads/${name}`
 	})
 
-const fetchCommit = (repoPath: string, sourceRef: string) =>
+const fetchCommit = (
+	repoPath: string,
+	sourceRef: string,
+	backend: VersionControlBackend,
+) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const temporaryRef = `refs/agency/review-fetch/${process.pid}-${randomUUID()}`
@@ -196,6 +201,17 @@ const fetchCommit = (repoPath: string, sourceRef: string) =>
 			],
 			{ captureOutput: true },
 		)
+		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 },
+			)
+			return yield* new ReviewError({
+				message: `Review source '${sourceRef}' did not resolve to a commit`,
+			})
+		}
+		const imported = yield* Effect.either(backend.importGitRefs(repoPath))
 		const cleanup = yield* fs.runCommand(
 			["git", "-C", repoPath, "update-ref", "-d", temporaryRef],
 			{ captureOutput: true },
@@ -205,10 +221,10 @@ const fetchCommit = (repoPath: string, sourceRef: string) =>
 				message: `Failed to remove temporary review fetch ref: ${cleanup.stderr.trim()}`,
 			})
 		}
-		const commit = resolved.stdout.trim()
-		if (resolved.exitCode !== 0 || !/^[a-f0-9]{40}$/.test(commit)) {
+		if (Either.isLeft(imported)) {
 			return yield* new ReviewError({
-				message: `Review source '${sourceRef}' did not resolve to a commit`,
+				message: `Review source '${sourceRef}' was fetched but could not be imported into ${backend.kind}`,
+				cause: imported.left,
 			})
 		}
 		return commit
@@ -225,6 +241,8 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 			) =>
 				Effect.gen(function* () {
 					const repositories = yield* RepositoryService
+					const versionControl = yield* VersionControlService
+					const backend = yield* versionControl.forWorkbase(startPath)
 					const repository = yield* repositories.show(repo, startPath)
 					if (!repository.remote || repository.states.includes("missing")) {
 						return yield* new ReviewError({
@@ -273,7 +291,7 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 							message: "Exactly one review source is required",
 						})
 					}
-					const commit = yield* fetchCommit(repository.path, sourceRef)
+					const commit = yield* fetchCommit(repository.path, sourceRef, backend)
 					return {
 						repo,
 						source,

package/src/services/VersionControlService.ts

@@ -47,6 +47,9 @@ export interface VersionControlBackend {
 		remote?: string,
 		branch?: string,
 	) => Effect.Effect<void, unknown, any>
+	readonly importGitRefs: (
+		repositoryPath: string,
+	) => Effect.Effect<void, unknown, any>
 	readonly push: (
 		workspacePath: string,
 		remote: string,
@@ -240,6 +243,7 @@ export class GitVersionControlService extends Effect.Service<GitVersionControlSe
 							),
 						)
 					}),
+				importGitRefs: () => Effect.void,
 				push: (workspacePath, remote, branch) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
@@ -333,18 +337,27 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 				resolveRevision: (repositoryPath, revision) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService
-						const result = yield* fs.runCommand(
-							jjCommand(repositoryPath, [
-								"log",
-								"--ignore-working-copy",
-								"--no-graph",
-								"-r",
-								revision,
-								"-T",
-								'commit_id ++ "\\n"',
-							]),
-							{ captureOutput: true },
-						)
+						const resolve = () =>
+							fs.runCommand(
+								jjCommand(repositoryPath, [
+									"log",
+									"--ignore-working-copy",
+									"--no-graph",
+									"-r",
+									revision,
+									"-T",
+									'commit_id ++ "\\n"',
+								]),
+								{ captureOutput: true },
+							)
+						let result = yield* resolve()
+						if (result.exitCode !== 0 || !result.stdout.trim()) {
+							const imported = yield* fs.runCommand(
+								jjCommand(repositoryPath, ["git", "import"]),
+								{ captureOutput: true },
+							)
+							if (imported.exitCode === 0) result = yield* resolve()
+						}
 						return result.exitCode === 0 ? result.stdout.trim() || null : null
 					}),
 				workspaceHead: (workspacePath) =>
@@ -430,6 +443,16 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 							),
 						)
 					}),
+				importGitRefs: (repositoryPath) =>
+					Effect.gen(function* () {
+						const fs = yield* FileSystemService
+						yield* requireSuccess(
+							"Failed to import Git refs into jj",
+							fs.runCommand(jjCommand(repositoryPath, ["git", "import"]), {
+								captureOutput: true,
+							}),
+						)
+					}),
 				push: (workspacePath, remote, branch) =>
 					Effect.gen(function* () {
 						const fs = yield* FileSystemService

package/src/services/WorktreeService.test.ts

@@ -164,6 +164,44 @@ describe("WorktreeService", () => {
 		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
 	})
 
+	test("recommends a repository fetch when jj cannot resolve a base", async () => {
+		if (!Bun.which("jj")) return
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await git(["clone", source, repository])
+		await jj(["git", "init", "--colocate", repository])
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "jj-missing",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/jj-missing",
+							base: "absent-base",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("jj-missing", undefined, root),
+					),
+				),
+			),
+		).rejects.toThrow("run 'agency repo fetch agency' and retry")
+	})
+
 	test("does not fetch the origin for an existing writable worktree", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/WorktreeService.ts

@@ -884,8 +884,12 @@ const materializeJj = (options: {
 					revision = yield* backend.resolveRevision(repositoryPath, base)
 				}
 				if (!revision) {
+					const recovery =
+						backend.kind === "jj"
+							? `; run 'agency repo fetch ${checkout.repo}' and retry`
+							: ""
 					return yield* new WorktreeError({
-						message: `${"branch" in checkout ? "Base" : "Reference"} '${"branch" in checkout ? base : checkout.ref}' for repository '${checkout.repo}' does not resolve to a commit`,
+						message: `${"branch" in checkout ? "Base" : "Reference"} '${"branch" in checkout ? base : checkout.ref}' for repository '${checkout.repo}' does not resolve to a commit${recovery}`,
 					})
 				}
 

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

@@ -3,6 +3,7 @@ import {
 	parsePullRequestRecord,
 	recordFromGitHubJson,
 	resolveDeliveryCommand,
+	resolveGitHubCreateCommand,
 	validateDelivery,
 } from "./delivery-command"
 
@@ -31,6 +32,34 @@ describe("delivery commands", () => {
 		})
 	})
 
+	test("adds explicit jj context to the default GitHub create command", () => {
+		const input = {
+			base: "main",
+			branch: "feat/example",
+			repository: "example/agency",
+			draft: false,
+		} as const
+		expect(resolveGitHubCreateCommand({ ...input, vcs: "jj" })).toEqual({
+			argv: [
+				"gh",
+				"pr",
+				"create",
+				"--fill",
+				"--base",
+				"main",
+				"--head",
+				"feat/example",
+				"--repo",
+				"example/agency",
+			],
+			environment: {},
+		})
+		expect(resolveGitHubCreateCommand({ ...input, vcs: "git" })).toEqual({
+			argv: ["gh", "pr", "create", "--fill", "--base", "main"],
+			environment: {},
+		})
+	})
+
 	test("rejects unknown placeholders", () => {
 		expect(() =>
 			validateDelivery({ ...delivery, queryCommand: ["forge", "{unknown}"] }),

package/src/workbase/delivery-command.ts

@@ -11,6 +11,39 @@ export interface DeliveryCommandVariables {
 	readonly identifier: string
 }
 
+export const repositoryFromRemote = (remote: string) =>
+	remote
+		.replace(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?[^/]+\//i, "")
+		.replace(/^[^:]+:/, "")
+		.replace(/\.git\/?$/, "")
+		.replace(/\/$/, "")
+
+export const resolveGitHubCreateCommand = ({
+	base,
+	branch,
+	repository,
+	draft,
+	vcs,
+}: {
+	readonly base: string
+	readonly branch: string
+	readonly repository: string
+	readonly draft: boolean
+	readonly vcs: "git" | "jj"
+}) => ({
+	argv: [
+		"gh",
+		"pr",
+		"create",
+		"--fill",
+		"--base",
+		base,
+		...(vcs === "jj" ? ["--head", branch, "--repo", repository] : []),
+		...(draft ? ["--draft"] : []),
+	],
+	environment: {},
+})
+
 const PLACEHOLDERS = new Set<keyof DeliveryCommandVariables>([
 	"repository",
 	"branch",