@markjaquith/agency 2.73.2 → 3.0.0

package/src/services/ArchiveService.ts

@@ -13,7 +13,6 @@ import {
 } from "./WorktreeService"
 import {
 	GitVersionControlService,
-	JjVersionControlService,
 	VersionControlService,
 } from "./VersionControlService"
 import {
@@ -368,7 +367,6 @@ const WorktreeLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,
 	GitVersionControlService.Default,
-	JjVersionControlService.Default,
 	VersionControlService.Default,
 	TaskService.Default,
 	PhaseService.Default,
@@ -400,22 +398,6 @@ const restoreWorktreeSnapshots = 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,
-			])
-			await runGit(["jj", "-R", snapshot.path, "edit", snapshot.head])
-			continue
-		}
 		await runGit(
 			snapshot.branch
 				? [
@@ -724,7 +706,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 						removedWorktrees.push(
 							...(yield* worktrees.remove(unit.taskId, unit.phaseId, root, {
 								dryRun: true,
-								persistResume: false,
 							})),
 						)
 					}
@@ -783,7 +764,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 												worktrees.remove(unit.taskId, unit.phaseId, root, {
 													snapshots,
 													lockHeld: true,
-													persistResume: false,
 												}),
 											)
 									} catch (cause) {
@@ -897,7 +877,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 							const result = yield* worktrees
 								.remove(unit.taskId, executionPhaseId(unit), root, {
 									dryRun: true,
-									persistResume: false,
 									task: context.task,
 									phase: unit.phaseId
 										? context.phases.find((phase) => phase.id === unit.phaseId)
@@ -1075,7 +1054,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 												worktrees.remove(unit.taskId, unit.phaseId, root, {
 													snapshots,
 													lockHeld: true,
-													persistResume: false,
 													task: contexts.get(unit.taskId)!.task,
 													phase: unit.phaseId
 														? contexts
@@ -1232,7 +1210,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 								root,
 								{
 									dryRun: true,
-									persistResume: false,
 								},
 							)),
 						)
@@ -1288,7 +1265,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													{
 														snapshots,
 														lockHeld: true,
-														persistResume: false,
 													},
 												),
 											)
@@ -1381,7 +1357,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					yield* rejectExistingDestination(destination, "Archive")
 					const removedWorktrees = yield* worktrees.remove(taskId, id, root, {
 						dryRun: true,
-						persistResume: false,
 					})
 					const at = new Date().toISOString()
 					const content = yield* declarationContent(task, {
@@ -1430,7 +1405,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													worktrees.remove(taskId, id, root, {
 														snapshots,
 														lockHeld: true,
-														persistResume: false,
 													}),
 												)
 											},

package/src/services/ContextService.ts

@@ -350,7 +350,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								root,
 								configPath: join(root, "agency.json"),
 								version: config.version,
-								vcs: config.vcs ?? "git",
+								vcs: "git",
 							},
 							target: { kind: "workbase", path: root },
 							hint: compact
@@ -1025,51 +1025,9 @@ export class ContextService extends Effect.Service<ContextService>()(
 					const inspectCheckout = (
 						repositoryPath: string,
 						checkoutPath: string,
-						expectedBranch: string | null = null,
-						branchCommit: string | null = null,
 					) =>
 						Effect.gen(function* (): Generator<any, CheckoutInspection, any> {
 							const materialized = yield* fs.isDirectory(checkoutPath)
-							if (backend.kind === "jj") {
-								const listed = yield* Effect.either(
-									backend.listWorkspaces(repositoryPath),
-								)
-								const workspaces = Either.isRight(listed) ? listed.right : []
-								if (Either.isLeft(listed)) {
-									inspectionWarnings.push(
-										`Unable to inspect jj workspace registrations for ${repositoryPath}`,
-									)
-								}
-								const canonicalCheckoutPath = materialized
-									? yield* fs.realPath(checkoutPath)
-									: resolve(checkoutPath)
-								const workspace = workspaces.find(
-									(workspace) => workspace.path === canonicalCheckoutPath,
-								)
-								const registered = workspace !== undefined
-								if (!materialized) {
-									return {
-										materialized: false,
-										registered,
-										checkoutCommit: null,
-										checkoutBranch: null,
-										detached: null,
-										dirty: null,
-									}
-								}
-								return {
-									materialized: true,
-									registered,
-									checkoutCommit: workspace?.commit ?? null,
-									checkoutBranch:
-										expectedBranch && branchCommit === workspace?.commit
-											? expectedBranch
-											: null,
-									detached:
-										!expectedBranch || branchCommit !== workspace?.commit,
-									dirty: workspace ? false : null,
-								}
-							}
 							const listed = yield* runGit(fs, repositoryPath, [
 								"worktree",
 								"list",
@@ -1136,7 +1094,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const repositoryPath =
 									repository?.path ?? join(root, "repos", executionData.repo)
 								const checkoutPath = join(codePath, executionData.repo)
-								let branchCommit = yield* backend.resolveRevision(
+								const branchCommit = yield* backend.resolveRevision(
 									repositoryPath,
 									executionData.branch,
 								)
@@ -1147,8 +1105,6 @@ export class ContextService extends Effect.Service<ContextService>()(
 								const checkout = yield* inspectCheckout(
 									repositoryPath,
 									checkoutPath,
-									executionData.branch,
-									branchCommit,
 								)
 								if (branchCommit === null) {
 									inspectionWarnings.push(
@@ -1239,9 +1195,10 @@ export class ContextService extends Effect.Service<ContextService>()(
 								? "complete"
 								: "partial"
 
+					const compact = !options.full
 					const projectDocument = <T>(document: Document<T> | null) =>
 						document
-							? options.compact
+							? compact
 								? {
 										id: document.id,
 										path: document.path,
@@ -1255,12 +1212,12 @@ export class ContextService extends Effect.Service<ContextService>()(
 						(task?.data && "repo" in task.data ? task.data : null)
 
 					return {
-						projection: options.compact ? "compact" : "complete",
+						projection: compact ? "compact" : "complete",
 						workbase: {
 							root,
 							configPath: join(root, "agency.json"),
 							version: config.version,
-							vcs: config.vcs ?? "git",
+							vcs: "git",
 						},
 						target,
 						documents: {
@@ -1308,7 +1265,7 @@ export class ContextService extends Effect.Service<ContextService>()(
 								writable: writableDocuments,
 							},
 						},
-						workspace: options.compact
+						workspace: compact
 							? {
 									codePath,
 									materialization,

package/src/services/DoctorService.ts

@@ -125,20 +125,12 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							return available
 						})
 
-					const [gitAvailable, jjAvailable] = yield* Effect.all(
-						[
-							tool("tool.git", "git", "error", "Git"),
-							tool(
-								"tool.jj",
-								"jj",
-								config.vcs === "jj" ? "error" : "optional",
-								"Jujutsu",
-							),
-						],
-						{ concurrency: "unbounded", batching: true },
+					const versionControlAvailable = yield* tool(
+						"tool.git",
+						"git",
+						"error",
+						"Git",
 					)
-					const versionControlAvailable =
-						gitAvailable && (config.vcs !== "jj" || jjAvailable)
 					yield* Effect.all(
 						[
 							tool(
@@ -180,15 +172,6 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									] as const,
 								]
 							: []),
-						...(config.workspaceCreateCommand
-							? [
-									[
-										"integration.workspace-create",
-										config.workspaceCreateCommand,
-										"Workspace creator",
-									] as const,
-								]
-							: []),
 						...Object.entries(config.repositories ?? {}).flatMap(
 							([alias, repository]) =>
 								repository.postCheckoutCommand
@@ -384,8 +367,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							category: "repository",
 							level: "warning",
 							status: "fail",
-							message: `Repository, ref, remote, and workspace checks were skipped because the ${config.vcs ?? "git"} backend is unavailable`,
-							remediation: `Install '${config.vcs === "jj" ? "jj" : "git"}' and rerun 'agency doctor'.`,
+							message:
+								"Repository, ref, remote, and workspace checks were skipped because Git is unavailable",
+							remediation: "Install 'git' and rerun 'agency doctor'.",
 						})
 					}
 					for (const repository of repositoryList) {

package/src/services/GraphService.test.ts

@@ -121,6 +121,7 @@ describe("GraphService", () => {
 		const graph = await getGraph(root)
 
 		expect(Schema.decodeUnknownSync(AgencyGraph)(graph)).toEqual(graph)
+		expect(graph.workbase.vcs).toBe("git")
 		expect(graph.nodes.map((node) => node.id)).toEqual([
 			"epic:delivery",
 			"execution-unit:phase/ship/implement",

package/src/services/GraphService.ts

@@ -821,10 +821,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 												checkoutCommit: materialized
 													? yield* backend.workspaceHead(checkoutPath)
 													: null,
-												checkoutBranch:
-													backend.kind === "jj" && materialized
-														? data.branch
-														: actualBranch,
+												checkoutBranch: actualBranch,
 												dirty: materialized
 													? yield* backend.workspaceDirty(checkoutPath)
 													: null,
@@ -1022,7 +1019,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						version: GRAPH_VERSION,
 						workbase: {
 							version: config.version,
-							vcs: config.vcs ?? "git",
+							vcs: "git",
 							...(include.has("workspace") ? { root } : {}),
 						},
 						filters,

package/src/services/IntegrationService.test.ts

@@ -186,6 +186,10 @@ describe("IntegrationService", () => {
 		}
 		expect(managedWorkbaseAgents).toContain("agency push --json")
 		expect(managedWorkbaseAgents).toContain("agency-execution-v1")
+		expect(managedWorkbaseAgents).toContain("agency context . --full --json")
+		expect(managedWorkbaseAgents).toContain(
+			"Workers use full context here because they need the assigned document prose",
+		)
 		expect(managedWorkbaseAgents).toContain(
 			"Never pass `--work` or `--auto` to `agency task create`",
 		)

package/src/services/PhaseService.ts

@@ -30,7 +30,6 @@ import {
 	buildNonPrCompletion,
 	type NonPrCompletionInput,
 } from "../workbase/completion"
-import { VersionControlService } from "./VersionControlService"
 
 class PhaseError extends Data.TaggedError("PhaseError")<{
 	readonly message: string
@@ -93,10 +92,8 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
-					const versionControl = yield* VersionControlService
 					const tasks = yield* TaskService
 					const root = yield* workbase.discover(startPath)
-					const backend = yield* versionControl.forWorkbase(root)
 					const taskId = yield* decodeId(input.taskId, "task")
 					const id = yield* decodeId(input.id, "phase")
 					const task = yield* tasks.show(taskId, root)
@@ -274,213 +271,95 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 								firstData.repo,
 								...(firstData.repos ?? []).map((reference) => reference.repo),
 							]
-							if (backend.kind === "jj") {
-								const workspaces: {
-									alias: string
-									name: string
-									head: string
-									oldPath: string
-									newPath: string
-								}[] = []
-								const runBackend = <A>(
-									effect: Effect.Effect<A, unknown, any>,
-								) =>
-									Effect.runPromise(
-										effect.pipe(
-											Effect.provideService(FileSystemService, fs),
-										) as Effect.Effect<A, unknown, never>,
-									)
-								steps.push({
-									label: `move jj workspaces for ${taskId}/${firstPhaseId}`,
-									preflight: async () => {
-										for (const entry of await readdir(oldCodePath)) {
-											if (!checkoutAliases.includes(entry))
-												throw new Error(
-													`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
-												)
-										}
-										for (const alias of checkoutAliases) {
-											const oldPath = join(oldCodePath, alias)
-											try {
-												await lstat(oldPath)
-											} catch {
-												continue
-											}
-											const expected = await realpath(oldPath)
-											const registered = (
-												await runBackend(
-													backend.listWorkspaces(join(root, "repos", alias)),
-												)
-											).find((workspace) => workspace.path === expected)
-											if (!registered?.name)
-												throw new Error(
-													`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a jj workspace`,
-												)
-											if (await runBackend(backend.workspaceDirty(oldPath)))
-												throw new Error(
-													`Cannot convert task '${taskId}'; jj workspace '${alias}' has uncommitted changes`,
-												)
-											const head = await runBackend(
-												backend.workspaceHead(oldPath),
-											)
-											if (!head)
-												throw new Error(
-													`Cannot resolve jj workspace '${alias}' before conversion`,
-												)
-											workspaces.push({
-												alias,
-												name: registered.name,
-												head,
-												oldPath,
-												newPath: join(firstCodePath, alias),
-											})
-										}
-									},
-									apply: async () => {
-										await mkdir(firstCodePath, { recursive: true })
-										for (const workspace of workspaces) {
-											const repositoryPath = join(
-												root,
-												"repos",
-												workspace.alias,
-											)
-											await runBackend(
-												backend.removeWorkspace({
-													repositoryPath,
-													workspacePath: workspace.oldPath,
-													workspaceName: workspace.name,
-												}),
-											)
-											await runBackend(
-												backend.createWorkspace({
-													repositoryPath,
-													workspacePath: workspace.newPath,
-													workspaceName: workspace.name,
-													revision: workspace.head,
-												}),
-											)
-										}
-										await rm(oldCodePath, { recursive: true, force: true })
-									},
-									rollback: async () => {
-										await mkdir(oldCodePath, { recursive: true })
-										for (const workspace of [...workspaces].reverse()) {
-											const repositoryPath = join(
-												root,
-												"repos",
-												workspace.alias,
-											)
-											await runBackend(
-												backend.removeWorkspace({
-													repositoryPath,
-													workspacePath: workspace.newPath,
-													workspaceName: workspace.name,
-												}),
-											)
-											await runBackend(
-												backend.createWorkspace({
-													repositoryPath,
-													workspacePath: workspace.oldPath,
-													workspaceName: workspace.name,
-													revision: workspace.head,
-												}),
+							const repair = async (basePath: string) => {
+								for (const alias of checkoutAliases) {
+									const checkoutPath = join(basePath, alias)
+									try {
+										await lstat(checkoutPath)
+									} catch {
+										continue
+									}
+									const result = Bun.spawnSync([
+										"git",
+										"-C",
+										join(root, "repos", alias),
+										"worktree",
+										"repair",
+										checkoutPath,
+									])
+									if (result.exitCode !== 0) {
+										throw new Error(
+											`Failed to repair moved worktree for '${alias}': ${new TextDecoder().decode(result.stderr)}`,
+										)
+									}
+								}
+							}
+							steps.push({
+								label: `move and repair code for ${taskId}/${firstPhaseId}`,
+								preflight: async () => {
+									for (const entry of await readdir(oldCodePath)) {
+										if (!checkoutAliases.includes(entry))
+											throw new Error(
+												`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
 											)
-										}
-										await rm(firstDirectory, { recursive: true, force: true })
-									},
-									manualRecovery: `Restore jj workspaces from ${firstCodePath} to ${oldCodePath}`,
-								})
-							} else {
-								const repair = async (basePath: string) => {
+									}
 									for (const alias of checkoutAliases) {
-										const checkoutPath = join(basePath, alias)
+										const checkoutPath = join(oldCodePath, alias)
 										try {
 											await lstat(checkoutPath)
 										} catch {
 											continue
 										}
-										const result = Bun.spawnSync([
+										const listed = Bun.spawnSync([
 											"git",
 											"-C",
 											join(root, "repos", alias),
 											"worktree",
-											"repair",
-											checkoutPath,
+											"list",
+											"--porcelain",
 										])
-										if (result.exitCode !== 0) {
+										if (listed.exitCode !== 0)
 											throw new Error(
-												`Failed to repair moved worktree for '${alias}': ${new TextDecoder().decode(result.stderr)}`,
+												`Failed to inspect worktrees for '${alias}'`,
 											)
-										}
-									}
-								}
-								steps.push({
-									label: `move and repair code for ${taskId}/${firstPhaseId}`,
-									preflight: async () => {
-										for (const entry of await readdir(oldCodePath)) {
-											if (!checkoutAliases.includes(entry))
-												throw new Error(
-													`Cannot convert task '${taskId}'; code contains unmanaged entry '${entry}'`,
-												)
-										}
-										for (const alias of checkoutAliases) {
-											const checkoutPath = join(oldCodePath, alias)
+										const expected = await realpath(checkoutPath)
+										let registered = false
+										for (const line of new TextDecoder()
+											.decode(listed.stdout)
+											.split("\n")) {
+											if (!line.startsWith("worktree ")) continue
 											try {
-												await lstat(checkoutPath)
-											} catch {
-												continue
-											}
-											const listed = Bun.spawnSync([
-												"git",
-												"-C",
-												join(root, "repos", alias),
-												"worktree",
-												"list",
-												"--porcelain",
-											])
-											if (listed.exitCode !== 0)
-												throw new Error(
-													`Failed to inspect worktrees for '${alias}'`,
-												)
-											const expected = await realpath(checkoutPath)
-											let registered = false
-											for (const line of new TextDecoder()
-												.decode(listed.stdout)
-												.split("\n")) {
-												if (!line.startsWith("worktree ")) continue
-												try {
-													if ((await realpath(line.slice(9))) === expected) {
-														registered = true
-														break
-													}
-												} catch {}
-											}
-											if (!registered)
-												throw new Error(
-													`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a Git worktree`,
-												)
-										}
-									},
-									apply: async () => {
-										await mkdir(firstDirectory, { recursive: true })
-										await rename(oldCodePath, firstCodePath)
-										try {
-											await repair(firstCodePath)
-										} catch (cause) {
-											await rename(firstCodePath, oldCodePath)
-											await repair(oldCodePath)
-											await rm(firstDirectory, { recursive: true, force: true })
-											throw cause
+												if ((await realpath(line.slice(9))) === expected) {
+													registered = true
+													break
+												}
+											} catch {}
 										}
-									},
-									rollback: async () => {
+										if (!registered)
+											throw new Error(
+												`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a Git worktree`,
+											)
+									}
+								},
+								apply: async () => {
+									await mkdir(firstDirectory, { recursive: true })
+									await rename(oldCodePath, firstCodePath)
+									try {
+										await repair(firstCodePath)
+									} catch (cause) {
 										await rename(firstCodePath, oldCodePath)
 										await repair(oldCodePath)
 										await rm(firstDirectory, { recursive: true, force: true })
-									},
-									manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
-								})
-							}
+										throw cause
+									}
+								},
+								rollback: async () => {
+									await rename(firstCodePath, oldCodePath)
+									await repair(oldCodePath)
+									await rm(firstDirectory, { recursive: true, force: true })
+								},
+								manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
+							})
 						}
 						steps.push(
 							documentWriteStep(root, [

package/src/services/PullRequestService.test.ts

@@ -98,7 +98,7 @@ describe("PullRequestService", () => {
 		await Bun.write(
 			path,
 			`#!/usr/bin/env bun
-await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd(), ...(process.env.GIT_DIR ? { gitDir: process.env.GIT_DIR } : {}) }))
+await Bun.write(${JSON.stringify(ghCallPath)}, JSON.stringify({ args: Bun.argv.slice(2), cwd: process.cwd() }))
 process.stdout.write(${JSON.stringify(stdout)})
 process.stderr.write(${JSON.stringify(stderr)})
 process.exit(${exitCode})
@@ -111,7 +111,6 @@ process.exit(${exitCode})
 		(await Bun.file(ghCallPath).json()) as {
 			args: string[]
 			cwd: string
-			gitDir?: string
 		}
 
 	const expectRemoteBranch = async (branch: string, exists = true) => {
@@ -243,49 +242,6 @@ process.exit(${exitCode})
 		expect(updated.endsWith(`${body}\n`)).toBe(true)
 	})
 
-	test("creates a PR from a non-colocated jj workspace with backing Git context", async () => {
-		if (!Bun.which("jj")) return
-		await rm(join(root, "repos/agency"), { recursive: true, force: true })
-		await requireCommand([
-			"jj",
-			"git",
-			"clone",
-			"--no-colocate",
-			remotePath,
-			join(root, "repos/agency"),
-		])
-		await requireCommand(
-			["jj", "config", "set", "--repo", "user.name", "Agency Test"],
-			join(root, "repos/agency"),
-		)
-		await requireCommand(
-			["jj", "config", "set", "--repo", "user.email", "agency@example.com"],
-			join(root, "repos/agency"),
-		)
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({ version: 2, vcs: "jj" }),
-		)
-		await createTask("jj-example", "task/jj-example")
-		const workspace = await materialize("jj-example")
-		await Bun.write(join(workspace.writablePath!, "CHANGE.md"), "jj change\n")
-		await requireCommand(
-			["jj", "describe", "-m", "feat: add jj example"],
-			workspace.writablePath!,
-		)
-		await requireCommand(["jj", "new"], workspace.writablePath!)
-		const url = "https://github.com/example/agency/pull/44"
-		await writeFakeGh({ stdout: `${url}\n` })
-
-		expect(await createPullRequest("jj-example")).toBe(url)
-		await expectRemoteBranch("task/jj-example")
-		const ghCall = await readGhCall()
-		expect(ghCall.args).toContain("--head")
-		expect(ghCall.args).toContain("--repo")
-		expect(ghCall.gitDir).toContain(".jj")
-		expect(await Bun.file(join(root, "repos/agency/.git")).exists()).toBe(false)
-	})
-
 	test("passes --draft to gh", async () => {
 		await createTask()
 		await writeFakeGh({