@markjaquith/agency 2.52.0 → 2.52.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.52.0",
+  "version": "2.52.2",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -20,6 +20,7 @@
   "files": [
     "index.ts",
     "cli.ts",
+    "cli-main.ts",
     "src",
     "schemas",
     "fixtures/protocol",

package/src/services/GraphMutationService.test.ts

@@ -158,6 +158,77 @@ describe("GraphMutationService", () => {
 		)
 	})
 
+	test("sets and clears pull request metadata with materialized code", async () => {
+		await mkdir(join(root, "tasks/alpha/code/agency"), { recursive: true })
+		await mkdir(join(root, "tasks/multi/phases/build/code/agency"), {
+			recursive: true,
+		})
+		const taskPr = "https://github.com/example/agency/pull/12"
+		const phasePr = "https://github.com/example/agency/pull/13"
+
+		await runTestEffect(
+			Effect.gen(function* () {
+				const mutations = yield* GraphMutationService
+				yield* mutations.updateTask("alpha", { pr: taskPr }, root)
+				yield* mutations.updatePhase("multi", "build", { pr: phasePr }, root)
+				const tasks = yield* TaskService
+				const phases = yield* PhaseService
+				expect((yield* tasks.show("alpha", root)).data).toMatchObject({
+					pr: taskPr,
+				})
+				expect((yield* phases.show("multi", "build", root)).data.pr).toBe(
+					phasePr,
+				)
+
+				yield* mutations.updateTask("alpha", { pr: null }, root)
+				yield* mutations.updatePhase("multi", "build", { pr: null }, root)
+				expect((yield* tasks.show("alpha", root)).data).toMatchObject({
+					pr: null,
+				})
+				expect((yield* phases.show("multi", "build", root)).data.pr).toBeNull()
+			}),
+		)
+	})
+
+	test("rejects checkout topology updates with materialized code", async () => {
+		await mkdir(join(root, "tasks/alpha/code/agency"), { recursive: true })
+		await mkdir(join(root, "tasks/multi/phases/build/code/agency"), {
+			recursive: true,
+		})
+		const topologyUpdates = [
+			{ repo: "docs" },
+			{ repos: [{ repo: "docs", ref: "main" }] },
+			{ branch: "feature/materialized" },
+			{ base: "develop" },
+		]
+
+		for (const updates of topologyUpdates) {
+			await expect(
+				runTestEffect(
+					Effect.gen(function* () {
+						return yield* (yield* GraphMutationService).updateTask(
+							"alpha",
+							updates,
+							root,
+						)
+					}),
+				),
+			).rejects.toThrow("materialized code")
+			await expect(
+				runTestEffect(
+					Effect.gen(function* () {
+						return yield* (yield* GraphMutationService).updatePhase(
+							"multi",
+							"build",
+							updates,
+							root,
+						)
+					}),
+				),
+			).rejects.toThrow("materialized code")
+		}
+	})
+
 	test("preserves dependency order and rejects cycles", async () => {
 		await runTestEffect(
 			Effect.gen(function* () {

package/src/services/GraphMutationService.ts

@@ -360,6 +360,12 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						"base",
 						"pr",
 					].some((key) => updates[key as keyof TaskUpdates] !== undefined)
+					const checkoutTopologyChange = [
+						"repo",
+						"repos",
+						"branch",
+						"base",
+					].some((key) => updates[key as keyof TaskUpdates] !== undefined)
 					if ("review" in record.data && executionChange) {
 						return yield* new GraphMutationError({
 							message: `Review task '${id}' does not have writable execution metadata`,
@@ -390,7 +396,7 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						})
 					}
 					if (
-						executionChange &&
+						checkoutTopologyChange &&
 						(yield* fs.isDirectory(join(dirname(record.path), "code")))
 					) {
 						return yield* new GraphMutationError({
@@ -506,8 +512,14 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						"base",
 						"pr",
 					].some((key) => updates[key as keyof PhaseUpdates] !== undefined)
+					const checkoutTopologyChange = [
+						"repo",
+						"repos",
+						"branch",
+						"base",
+					].some((key) => updates[key as keyof PhaseUpdates] !== undefined)
 					if (
-						executionChange &&
+						checkoutTopologyChange &&
 						(yield* fs.isDirectory(join(dirname(record.path), "code")))
 					) {
 						return yield* new GraphMutationError({

package/src/services/TaskService.ts

@@ -34,7 +34,7 @@ class TaskError extends Data.TaggedError("TaskError")<{
 	readonly message: string
 }> {}
 
-interface TaskRecord {
+export interface TaskRecord {
 	readonly id: string
 	readonly path: string
 	readonly content: string

package/src/services/VcsMigrationService.test.ts

@@ -7,6 +7,7 @@ import { ClaimService } from "./ClaimService"
 import { TaskService } from "./TaskService"
 import { VcsMigrationService } from "./VcsMigrationService"
 import { WorktreeService } from "./WorktreeService"
+import { runVcsStatusFast } from "../vcs-status-fast"
 
 const run = async (args: string[], cwd?: string) => {
 	const child = Bun.spawn(args, { cwd, stdout: "pipe", stderr: "pipe" })
@@ -72,6 +73,51 @@ describe("VcsMigrationService", () => {
 
 	afterEach(async () => cleanupTempDir(root))
 
+	test("reports same-backend status for materialized workspaces", async () => {
+		const status = await runTestEffect(
+			VcsMigrationService.pipe(
+				Effect.flatMap((service) => service.status(root)),
+			),
+		)
+		expect(status).toMatchObject({
+			configured: "git",
+			source: "git",
+			target: "git",
+			workspaceCount: 2,
+			blockers: [],
+		})
+	})
+
+	test("fast jj status matches the validated service result", async () => {
+		if (!Bun.which("jj")) return
+		await runTestEffect(
+			VcsMigrationService.pipe(
+				Effect.flatMap((service) =>
+					service.migrate("jj", root, { apply: true }),
+				),
+			),
+		)
+		const taskPath = join(root, "tasks/example/TASK.md")
+		const content = await Bun.file(taskPath).text()
+		const withoutReference = content.replace(
+			/\nrepos:\n(?:  .+\n)+(?=branch:)/,
+			"\n",
+		)
+		expect(withoutReference).not.toBe(content)
+		await Bun.write(taskPath, withoutReference)
+
+		const validated = await runTestEffect(
+			VcsMigrationService.pipe(
+				Effect.flatMap((service) => service.status(root)),
+			),
+		)
+		const output: string[] = []
+		expect(
+			await runVcsStatusFast(true, root, (line) => output.push(line)),
+		).toBe(true)
+		expect(JSON.parse(output.join("\n")).result).toEqual(validated)
+	})
+
 	test("migrates Git worktrees to jj workspaces and back", async () => {
 		if (!Bun.which("jj")) return
 		const checkout = join(root, "tasks/example/code/agency")

package/src/services/VcsMigrationService.ts

@@ -8,7 +8,7 @@ import {
 	runLifecycleTransaction,
 } from "./LifecycleTransaction"
 import { FileSystemService } from "./FileSystemService"
-import { PhaseService } from "./PhaseService"
+import { PhaseService, type PhaseRecord } from "./PhaseService"
 import { RepositoryService } from "./RepositoryService"
 import { TaskService } from "./TaskService"
 import {
@@ -182,15 +182,19 @@ const executionRecords = (root: string) =>
 	Effect.gen(function* () {
 		const tasks = yield* TaskService
 		const phases = yield* PhaseService
+		const taskRecords = yield* tasks.list(root)
+		const phasesByTask = new Map<string, readonly PhaseRecord[]>()
 		const records: {
 			taskId: string
 			phaseId?: string
 			status: WorkStatus
 			claimActive: boolean
 		}[] = []
-		for (const task of yield* tasks.list(root)) {
+		for (const task of taskRecords) {
 			if ("phases" in task.data) {
-				for (const phase of yield* phases.list(task.id, root)) {
+				const phaseRecords = yield* phases.list(task.id, root)
+				phasesByTask.set(task.id, phaseRecords)
+				for (const phase of phaseRecords) {
 					records.push({
 						taskId: task.id,
 						phaseId: phase.id,
@@ -206,7 +210,7 @@ const executionRecords = (root: string) =>
 				})
 			}
 		}
-		return records
+		return { records, taskRecords, phasesByTask }
 	})
 
 const inspectMigration = (startPath: string, requestedTarget?: VcsKind) =>
@@ -241,7 +245,8 @@ const inspectMigration = (startPath: string, requestedTarget?: VcsKind) =>
 			})
 		}
 
-		const records = yield* executionRecords(root)
+		const execution = yield* executionRecords(root)
+		const records = execution.records
 		for (const record of records) {
 			if (record.claimActive) {
 				const label = record.phaseId
@@ -339,7 +344,15 @@ const inspectMigration = (startPath: string, requestedTarget?: VcsKind) =>
 		}
 
 		const workspacePlans: WorkspacePlan[] = []
-		const inspected = yield* Effect.either(worktrees.list(root))
+		const inspected = yield* Effect.either(
+			worktrees.list(root, {
+				materializedOnly: !blockers.some(
+					(blocker) => blocker.kind === "repository",
+				),
+				tasks: execution.taskRecords,
+				phasesByTask: execution.phasesByTask,
+			}),
+		)
 		if (Either.isLeft(inspected)) {
 			blockers.push({
 				kind: "workspace-conflict",
@@ -377,26 +390,27 @@ const inspectMigration = (startPath: string, requestedTarget?: VcsKind) =>
 						continue
 					}
 					const sourceName =
-						source === "jj"
+						source !== target && source === "jj"
 							? ((yield* sourceBackend.listWorkspaces(
 									join(root, "repos", checkout.repo),
 								)).find((item) => item.path === checkout.registeredPath)
 									?.name ?? null)
 							: null
-					const previousBranchCommit = checkout.actualBranch
-						? yield* command(
-								fs,
-								[
-									"git",
-									"-C",
-									join(root, "repos", checkout.repo),
-									"rev-parse",
-									"--verify",
-									`${checkout.actualBranch}^{commit}`,
-								],
-								`Failed to inspect branch '${checkout.actualBranch}'`,
-							).pipe(Effect.catchAll(() => Effect.succeed(null)))
-						: null
+					const previousBranchCommit =
+						source !== target && checkout.actualBranch
+							? yield* command(
+									fs,
+									[
+										"git",
+										"-C",
+										join(root, "repos", checkout.repo),
+										"rev-parse",
+										"--verify",
+										`${checkout.actualBranch}^{commit}`,
+									],
+									`Failed to inspect branch '${checkout.actualBranch}'`,
+								).pipe(Effect.catchAll(() => Effect.succeed(null)))
+							: null
 					workspacePlans.push({
 						taskId: inspection.owner.taskId,
 						...(inspection.owner.phaseId

package/src/services/VersionControlService.ts

@@ -3,11 +3,13 @@ import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
 import type { VersionControlKind } from "../workbase/version-control"
 
-interface RegisteredWorkspace {
+export interface RegisteredWorkspace {
 	readonly name: string | null
 	readonly path: string
 	readonly commit: string | null
 	readonly branch: string | null
+	readonly head?: string | null
+	readonly dirty?: boolean
 }
 
 export interface VersionControlBackend {
@@ -305,7 +307,7 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 									"workspace",
 									"list",
 									"-T",
-									'name ++ "\\t" ++ root ++ "\\t" ++ target.commit_id() ++ "\\n"',
+									'name ++ "\\t" ++ root ++ "\\t" ++ target.commit_id() ++ "\\t" ++ target.parents().map(|commit| commit.commit_id()).join(",") ++ "\\t" ++ target.empty() ++ "\\n"',
 								]),
 								{ captureOutput: true },
 							),
@@ -315,12 +317,16 @@ export class JjVersionControlService extends Effect.Service<JjVersionControlServ
 							.split("\n")
 							.filter(Boolean)
 							.map((line) => {
-								const [name, path, commit] = line.split("\t")
+								const [name, path, commit, parents, empty] = line.split("\t")
+								const parentCommits = parents?.split(",").filter(Boolean) ?? []
 								return {
 									name: name || null,
 									path: path!,
 									commit: commit || null,
 									branch: null,
+									head:
+										parentCommits.length === 1 ? parentCommits[0]! : undefined,
+									dirty: empty === "false",
 								}
 							})
 					}),