@markjaquith/agency 2.50.0 → 2.51.0

package/src/services/RepositoryService.ts

@@ -17,6 +17,10 @@ import {
 	WorkbaseConfig,
 } from "../workbase/schemas"
 import { documentRevision } from "../workbase/document-revision"
+import {
+	VersionControlService,
+	type VersionControlBackend,
+} from "./VersionControlService"
 
 class RepositoryError extends Data.TaggedError("RepositoryError")<{
 	readonly message: string
@@ -207,7 +211,11 @@ const requireMaterialized = (repository: RepositoryInfo) =>
 				)
 			: Effect.succeed(repository)
 
-const removalBlockers = (repository: RepositoryInfo, startPath: string) =>
+const removalBlockers = (
+	repository: RepositoryInfo,
+	startPath: string,
+	backend: VersionControlBackend,
+) =>
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const graph = yield* GraphService
@@ -223,28 +231,29 @@ const removalBlockers = (repository: RepositoryInfo, startPath: string) =>
 			.sort()
 		const worktrees: string[] = []
 		if (repository.kind !== null && !repository.states.includes("invalid")) {
+			const repositoryTarget = yield* fs.realPath(repository.path)
 			const linkedTarget =
 				repository.kind === "symlink"
 					? yield* fs.realPath(repository.path)
 					: null
-			const result = yield* fs.runCommand(
-				["git", "-C", repository.path, "worktree", "list", "--porcelain"],
-				{ captureOutput: true },
-			)
-			if (result.exitCode === 0) {
-				for (const block of result.stdout.trim().split(/\n\n+/)) {
-					if (!block || /(^|\n)bare(\n|$)/.test(block)) continue
-					const path = block.match(/^worktree (.+)$/m)?.[1]
-					if (path && path !== linkedTarget) worktrees.push(path)
-				}
+			for (const workspace of yield* backend.listWorkspaces(repository.path)) {
+				if (
+					workspace.path !== repositoryTarget &&
+					workspace.path !== linkedTarget
+				)
+					worktrees.push(workspace.path)
 			}
 		}
 		return { references, worktrees }
 	})
 
-const assertRemovable = (repository: RepositoryInfo, startPath: string) =>
+const assertRemovable = (
+	repository: RepositoryInfo,
+	startPath: string,
+	backend: VersionControlBackend,
+) =>
 	Effect.gen(function* () {
-		const blockers = yield* removalBlockers(repository, startPath)
+		const blockers = yield* removalBlockers(repository, startPath, backend)
 		const details = [
 			...blockers.references.map((item) => `active reference ${item}`),
 			...blockers.worktrees.map((item) => `linked worktree ${item}`),
@@ -258,10 +267,11 @@ const assertRemovable = (repository: RepositoryInfo, startPath: string) =>
 
 const effectPreflightStep = (
 	label: string,
-	check: Effect.Effect<void, unknown, never>,
+	check: Effect.Effect<void, unknown, any>,
 ): TransactionStep => ({
 	label,
-	preflight: () => Effect.runPromise(check),
+	preflight: () =>
+		Effect.runPromise(check as Effect.Effect<void, unknown, never>),
 	apply: async () => undefined,
 })
 
@@ -341,8 +351,10 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 			add: (alias: string, remote: string, startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const validAlias = yield* validateAlias(alias)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const destination = join(state.root, "repos", validAlias)
 					if (
 						state.config.repositories?.[validAlias] ||
@@ -369,7 +381,14 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					)
 					yield* fs.createDirectory(join(state.root, "repos"))
 					const cloned = yield* fs.runCommand(
-						["git", "clone", "--bare", "--", cloneSource, staging],
+						[
+							"git",
+							"clone",
+							...(backend.kind === "git" ? ["--bare"] : []),
+							"--",
+							cloneSource,
+							staging,
+						],
 						{ captureOutput: true },
 					)
 					if (cloned.exitCode !== 0) {
@@ -378,6 +397,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							message: `Failed to clone repository '${remote}': ${cloned.stderr.trim()}`,
 						})
 					}
+					yield* backend.initializeRepository(staging)
 					if (declaredRemote !== remote) {
 						const setRemote = yield* fs.runCommand(
 							[
@@ -417,10 +437,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const graph = yield* GraphService
 					const workbase = yield* WorkbaseService
 					const validAlias = yield* validateAlias(alias)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const destination = join(state.root, "repos", validAlias)
 					const resolvedTarget = resolve(startPath, target)
 					const existing = (yield* RepositoryService)
@@ -452,6 +474,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							message: `Path is not a Git repository: ${resolvedTarget}`,
 						})
 					}
+					yield* backend.initializeRepository(resolvedTarget)
 					const declaredRemote =
 						state.config.repositories?.[validAlias]?.remote ??
 						(yield* portableRemote(resolvedTarget))
@@ -474,7 +497,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const safety = localCurrent
 						? effectPreflightStep(
 								`verify repository safety for ${validAlias}`,
-								assertRemovable(localCurrent, state.root).pipe(
+								assertRemovable(localCurrent, state.root, backend).pipe(
 									Effect.provideService(FileSystemService, fs),
 									Effect.provideService(GraphService, graph),
 									Effect.provideService(WorkbaseService, workbase),
@@ -584,19 +607,12 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 
 			fetch: (alias: string, startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath).pipe(
 						Effect.flatMap(requireMaterialized),
 					)
-					const result = yield* fs.runCommand(
-						["git", "-C", repository.path, "fetch", "--prune"],
-						{ captureOutput: true },
-					)
-					if (result.exitCode !== 0) {
-						return yield* new RepositoryError({
-							message: `Failed to fetch repository '${alias}': ${result.stderr.trim()}`,
-						})
-					}
+					const backend = yield* versionControl.forWorkbase(startPath)
+					yield* backend.fetch(repository.path, undefined, undefined)
 					return repository
 				}),
 
@@ -605,8 +621,10 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const fs = yield* FileSystemService
 					const graph = yield* GraphService
 					const workbase = yield* WorkbaseService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const declarations = { ...(state.config.repositories ?? {}) }
 					delete declarations[repository.alias]
 					const config = withDeclarations(state.config, declarations)
@@ -618,7 +636,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					)
 					const safety = effectPreflightStep(
 						`verify repository safety for ${repository.alias}`,
-						assertRemovable(repository, startPath).pipe(
+						assertRemovable(repository, startPath, backend).pipe(
 							Effect.provideService(FileSystemService, fs),
 							Effect.provideService(GraphService, graph),
 							Effect.provideService(WorkbaseService, workbase),
@@ -642,6 +660,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const fs = yield* FileSystemService
 					const graph = yield* GraphService
 					const workbase = yield* WorkbaseService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath)
 					if (repository.kind !== "symlink") {
 						return yield* new RepositoryError({
@@ -649,6 +668,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						})
 					}
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const staging = join(
 						state.root,
 						"repos",
@@ -660,7 +680,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 						steps: [
 							effectPreflightStep(
 								`verify repository safety for ${repository.alias}`,
-								assertRemovable(repository, startPath).pipe(
+								assertRemovable(repository, startPath, backend).pipe(
 									Effect.provideService(FileSystemService, fs),
 									Effect.provideService(GraphService, graph),
 									Effect.provideService(WorkbaseService, workbase),
@@ -685,9 +705,11 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const fs = yield* FileSystemService
 					const graph = yield* GraphService
 					const workbase = yield* WorkbaseService
+					const versionControl = yield* VersionControlService
 					const repository = yield* find(alias, startPath)
 					const validNewAlias = yield* validateAlias(newAlias)
 					const state = yield* configState(startPath)
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const destination = join(state.root, "repos", validNewAlias)
 					if (
 						state.config.repositories?.[validNewAlias] ||
@@ -712,7 +734,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 					const exists = yield* fs.exists(repository.path)
 					const safety = effectPreflightStep(
 						`verify repository safety for ${repository.alias}`,
-						assertRemovable(repository, startPath).pipe(
+						assertRemovable(repository, startPath, backend).pipe(
 							Effect.provideService(FileSystemService, fs),
 							Effect.provideService(GraphService, graph),
 							Effect.provideService(WorkbaseService, workbase),
@@ -843,7 +865,9 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 				Effect.gen(function* () {
 					const service = yield* RepositoryService
 					const fs = yield* FileSystemService
+					const versionControl = yield* VersionControlService
 					const state = yield* configState(options.cwd ?? process.cwd())
+					const backend = yield* versionControl.forWorkbase(state.root)
 					const repositories = yield* service.list(state.root)
 					const planned: Omit<RepositorySetupAction, "status">[] = []
 					const unresolved: RepositorySetupIssue[] = []
@@ -913,7 +937,14 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							)
 							yield* fs.createDirectory(join(state.root, "repos"))
 							const cloned = yield* fs.runCommand(
-								["git", "clone", "--bare", "--", action.remote, from],
+								[
+									"git",
+									"clone",
+									...(backend.kind === "git" ? ["--bare"] : []),
+									"--",
+									action.remote,
+									from,
+								],
 								{ captureOutput: true },
 							)
 							if (cloned.exitCode !== 0) {
@@ -923,6 +954,7 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 									message: `Failed to materialize repository '${action.alias}': ${cloned.stderr.trim()}`,
 								})
 							}
+							yield* backend.initializeRepository(from)
 							staging.push({
 								alias: action.alias,
 								from,

package/src/services/ReviewService.ts

@@ -11,6 +11,11 @@ import {
 	WorktreeService,
 	type WorktreeRemovalSnapshot,
 } from "./WorktreeService"
+import {
+	GitVersionControlService,
+	JjVersionControlService,
+	VersionControlService,
+} from "./VersionControlService"
 import { withWorktreeLocks } from "./WorktreeLock"
 import {
 	documentWriteStep,
@@ -53,6 +58,9 @@ const runGit = async (args: readonly string[]) => {
 const WorktreeLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
+	GitVersionControlService.Default,
+	JjVersionControlService.Default,
+	VersionControlService.Default,
 	TaskService.Default,
 	PhaseService.Default,
 	WorktreeService.Default,
@@ -72,6 +80,21 @@ const restoreSnapshots = async (
 			continue
 		} catch {}
 		await mkdir(dirname(snapshot.path), { recursive: true })
+		if (snapshot.vcs === "jj") {
+			await runGit([
+				"jj",
+				"-R",
+				snapshot.repositoryPath,
+				"workspace",
+				"add",
+				"--name",
+				snapshot.workspaceName!,
+				"-r",
+				snapshot.head,
+				snapshot.path,
+			])
+			continue
+		}
 		await runGit(
 			snapshot.branch
 				? [

package/src/services/SyncService.test.ts

@@ -22,6 +22,18 @@ const git = async (args: string[], cwd?: string) => {
 	}
 }
 
+const jj = async (args: string[], cwd?: string) => {
+	const process = Bun.spawn(["jj", ...args], {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0) {
+		throw new Error(await new Response(process.stderr).text())
+	}
+}
+
 describe("SyncService", () => {
 	let root: string
 	let originalPath: string | undefined
@@ -109,6 +121,61 @@ pr: null
 		expect(await Bun.file(join(root, "repos/agency")).exists()).toBe(false)
 	})
 
+	test("reconciles jj workspaces through the jj backend", async () => {
+		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 Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "jj-sync",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/jj-sync",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const planned = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) => service.reconcile({ cwd: root })),
+			),
+		)
+		expect(planned.changes).toContainEqual(
+			expect.objectContaining({
+				kind: "materialize-workspace",
+				target: "task:jj-sync",
+				status: "planned",
+			}),
+		)
+
+		const applied = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({ cwd: root, apply: true }),
+				),
+			),
+		)
+		expect(applied.executions[0]?.checkouts[0]).toMatchObject({
+			exists: true,
+			registered: true,
+			branch: "task/jj-sync",
+			dirty: false,
+		})
+	})
+
 	test("observes drift without mutation and applies only safe transitions", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/SyncService.ts

@@ -25,6 +25,7 @@ import {
 	RepositoryService,
 	type RepositorySetupResult,
 } from "./RepositoryService"
+import { VersionControlService } from "./VersionControlService"
 
 class SyncError extends Data.TaggedError("SyncError")<{
 	readonly message: string
@@ -161,7 +162,9 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const worktrees = yield* WorktreeService
 				const claims = yield* ClaimService
 				const repositories = yield* RepositoryService
+				const versionControl = yield* VersionControlService
 				const { root, config } = yield* workbase.loadConfig(options.cwd)
+				const backend = yield* versionControl.forWorkbase(root)
 				const validation = yield* workbase.validate(root)
 				if (!validation.valid) {
 					return yield* new SyncError({
@@ -268,33 +271,27 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							workspaceConflict = true
 							continue
 						}
-						const listed = yield* fs.runCommand(
-							[
-								"git",
-								"-C",
-								repositoryPath,
-								"worktree",
-								"list",
-								"--porcelain",
-								"-z",
-							],
-							{ captureOutput: true },
+						const listed = yield* Effect.either(
+							backend.listWorkspaces(repositoryPath),
 						)
-						if (listed.exitCode !== 0) {
+						if (Either.isLeft(listed)) {
 							unresolved.push({
 								kind: "worktree-inspection-failed",
 								target: record.key,
-								message:
-									listed.stderr.trim() || `Cannot inspect '${checkout.repo}'`,
+								message: `Cannot inspect '${checkout.repo}'`,
 							})
 							workspaceConflict = true
 							continue
 						}
 						const exists = yield* fs.isDirectory(checkoutPath)
 						const registered: RegisteredWorktree[] = []
-						for (const item of parseWorktrees(listed.stdout)) {
+						for (const item of listed.right) {
 							registered.push({
-								...item,
+								head: item.commit,
+								branch:
+									backend.kind === "jj" && "branch" in checkout
+										? checkout.branch
+										: item.branch,
 								path: (yield* fs.exists(item.path))
 									? yield* fs.realPath(item.path)
 									: resolve(item.path),
@@ -306,39 +303,36 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								? join(yield* fs.realPath(codePath), checkout.repo)
 								: resolve(checkoutPath)
 						let atPath = registered.find((item) => item.path === expectedPath)
+						if (backend.kind === "jj" && atPath && exists) {
+							atPath = {
+								...atPath,
+								head: yield* backend.workspaceHead(checkoutPath),
+							}
+						}
 						const branchRef =
-							"branch" in checkout ? `refs/heads/${checkout.branch}` : null
-						const branchElsewhere = branchRef
-							? registered.find(
-									(item) =>
-										item.branch === branchRef && item.path !== expectedPath,
-								)
-							: undefined
+							"branch" in checkout
+								? backend.kind === "jj"
+									? checkout.branch
+									: `refs/heads/${checkout.branch}`
+								: null
+						const branchElsewhere =
+							branchRef && backend.kind !== "jj"
+								? registered.find(
+										(item) =>
+											item.branch === branchRef && item.path !== expectedPath,
+									)
+								: undefined
 						if ("branch" in checkout && !exists && !branchElsewhere) {
-							const branch = yield* fs.runCommand(
-								[
-									"git",
-									"-C",
-									repositoryPath,
-									"rev-parse",
-									"--verify",
-									`${checkout.branch}^{commit}`,
-								],
-								{ captureOutput: true },
+							const branch = yield* backend.resolveRevision(
+								repositoryPath,
+								checkout.branch,
 							)
-							if (branch.exitCode !== 0) {
-								const base = yield* fs.runCommand(
-									[
-										"git",
-										"-C",
-										repositoryPath,
-										"rev-parse",
-										"--verify",
-										`${data.base}^{commit}`,
-									],
-									{ captureOutput: true },
+							if (!branch) {
+								const base = yield* backend.resolveRevision(
+									repositoryPath,
+									data.base,
 								)
-								if (base.exitCode !== 0) {
+								if (!base) {
 									unresolved.push({
 										kind: "unresolved-base",
 										target: record.key,
@@ -404,22 +398,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 									})
 								}
 							}
-							const resolvedRef = resolvedCommit
-								? null
-								: yield* fs.runCommand(
-										[
-											"git",
-											"-C",
-											repositoryPath,
-											"rev-parse",
-											"--verify",
-											`${checkout.ref}^{commit}`,
-										],
-										{ captureOutput: true },
-									)
-							if (resolvedRef?.exitCode === 0) {
-								resolvedCommit = resolvedRef.stdout.trim()
-							}
+							resolvedCommit ??= yield* backend.resolveRevision(
+								repositoryPath,
+								checkout.ref,
+							)
 							if (!resolvedCommit) {
 								unresolved.push({
 									kind: "unresolved-reference",
@@ -431,23 +413,15 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							}
 						}
 
-						const dirtyResult =
+						const dirty =
 							exists && atPath
-								? yield* fs.runCommand(
-										["git", "-C", checkoutPath, "status", "--porcelain"],
-										{ captureOutput: true },
-									)
-								: null
-						const dirty = dirtyResult
-							? dirtyResult.exitCode === 0
-								? dirtyResult.stdout.length > 0
+								? yield* backend.workspaceDirty(checkoutPath)
 								: null
-							: null
-						if (dirtyResult && dirtyResult.exitCode !== 0) {
+						if (exists && atPath && dirty === null) {
 							warnings.push({
 								kind: "status-inspection-failed",
 								target: record.key,
-								message: `Could not inspect dirtiness for ${checkoutPath}: ${dirtyResult.stderr.trim()}`,
+								message: `Could not inspect dirtiness for ${checkoutPath}`,
 								action: "Inspect the checkout manually before changing it",
 							})
 						}
@@ -607,15 +581,8 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					let prConflict = false
 					const repositoryPath = join(root, "repos", data.repo)
 					const remoteName = config.delivery?.remote ?? "origin"
-					const remote = yield* runExternal([
-						"git",
-						"-C",
-						repositoryPath,
-						"remote",
-						"get-url",
-						remoteName,
-					])
-					const remoteRepository = remote.stdout
+					const remoteUrl = yield* backend.remoteUrl(repositoryPath, remoteName)
+					const remoteRepository = (remoteUrl ?? "")
 						.trim()
 						.replace(/^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?[^/]+\//i, "")
 						.replace(/^[^:]+:/, "")
@@ -635,11 +602,11 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 
-					if (config.delivery && remote.exitCode !== 0) {
+					if (config.delivery && !remoteUrl) {
 						warnings.push({
 							kind: "delivery-remote-unavailable",
 							target: record.key,
-							message: `Could not inspect delivery remote '${remoteName}': ${remote.stderr.trim()}`,
+							message: `Could not inspect delivery remote '${remoteName}'`,
 						})
 					} else if (config.delivery) {
 						const resolved = resolveDeliveryCommand(config.delivery, "query", {

package/src/services/TaskPhaseService.test.ts

@@ -7,6 +7,13 @@ import { EpicService } from "./EpicService"
 import { TaskService } from "./TaskService"
 import { PhaseService } from "./PhaseService"
 import { PullRequestService } from "./PullRequestService"
+import { WorktreeService } from "./WorktreeService"
+
+const run = async (args: string[], cwd?: string) => {
+	const child = Bun.spawn(args, { cwd, stdout: "pipe", stderr: "pipe" })
+	const exitCode = await child.exited
+	if (exitCode !== 0) throw new Error(await new Response(child.stderr).text())
+}
 
 describe("task and phase services", () => {
 	let root: string
@@ -283,6 +290,79 @@ describe("task and phase services", () => {
 		})
 	})
 
+	test("recreates jj workspaces when converting a task to phases", async () => {
+		if (!Bun.which("jj")) return
+		const source = join(root, "source")
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await mkdir(source)
+		await run(["git", "init", "--initial-branch=main"], source)
+		await run(["git", "config", "user.email", "test@example.com"], source)
+		await run(["git", "config", "user.name", "Test"], source)
+		await Bun.write(join(source, "README.md"), "example\n")
+		await run(["git", "add", "README.md"], source)
+		await run(["git", "commit", "-m", "initial"], source)
+		await run(["git", "clone", source, repository])
+		await run(["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-single",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/jj-single",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("jj-single", undefined, root),
+				),
+			),
+		)
+
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							taskId: "jj-single",
+							id: "extra",
+							firstPhase: "implementation",
+							repo: "agency",
+							branch: "task/extra",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const moved = join(
+			root,
+			"tasks/jj-single/phases/implementation/code/agency",
+		)
+		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
+		expect(await Bun.file(join(moved, "README.md")).text()).toBe("example\n")
+		const listed = Bun.spawnSync(
+			["jj", "-R", repository, "workspace", "list", "-T", 'root ++ "\\n"'],
+			{ stdout: "pipe" },
+		)
+		expect(new TextDecoder().decode(listed.stdout)).toContain(moved)
+	})
+
 	test("preserves non-PR completion when converting a task to phases", async () => {
 		await runTestEffect(
 			TaskService.pipe(