@markjaquith/agency 2.58.1 → 2.58.2

package/package.json

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

package/src/services/WorktreeService.test.ts

@@ -1882,6 +1882,111 @@ pr: null
 		).toBe(true)
 	})
 
+	test("rebuilds clean drifted jj references without discarding changes", async () => {
+		if (!Bun.which("jj")) return
+		const first = new TextDecoder()
+			.decode(
+				Bun.spawnSync(["git", "-C", source, "rev-parse", "HEAD"], {
+					stdout: "pipe",
+				}).stdout,
+			)
+			.trim()
+		await Bun.write(join(source, "README.md"), "updated\n")
+		await git(["add", "README.md"], source)
+		await git(["-c", "commit.gpgsign=false", "commit", "-m", "update"], source)
+		const second = new TextDecoder()
+			.decode(
+				Bun.spawnSync(["git", "-C", source, "rev-parse", "HEAD"], {
+					stdout: "pipe",
+				}).stdout,
+			)
+			.trim()
+		const repository = join(root, "repos/agency")
+		await rm(repository, { recursive: true, force: true })
+		await jj(["git", "clone", "--no-colocate", source, repository])
+		await Bun.write(
+			join(root, "agency.json"),
+			JSON.stringify({ version: 2, vcs: "jj" }),
+		)
+		const createDriftedReview = async (id: string) => {
+			const task = await runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.create(
+							{
+								id,
+								ticketUrl: null,
+								review: {
+									repo: "agency",
+									source: {
+										kind: "branch",
+										ref: "refs/heads/main",
+									},
+									commit: first,
+									refreshedAt: "2026-08-10T00:00:00.000Z",
+								},
+							},
+							root,
+						),
+					),
+				),
+			)
+			const workspace = await runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) => service.materialize(id, undefined, root)),
+				),
+			)
+			await Bun.write(task.path, task.content.replace(first, second))
+			return workspace
+		}
+
+		const workspace = await createDriftedReview("drifted-review")
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("drifted-review", undefined, root),
+					),
+				),
+			),
+		).rejects.toThrow("does not match reference")
+		const inspection = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.inspect("drifted-review", undefined, root),
+				),
+			),
+		)
+		expect(inspection.conflicts).toEqual([
+			expect.objectContaining({ kind: "reference-drift" }),
+		])
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.rebuild("drifted-review", undefined, root),
+				),
+			),
+		)
+		expect(
+			await Bun.file(join(workspace.reviewPath!, "README.md")).text(),
+		).toBe("updated\n")
+
+		const dirtyWorkspace = await createDriftedReview("dirty-drifted-review")
+		const dirtyPath = join(dirtyWorkspace.reviewPath!, "dirty.txt")
+		await Bun.write(dirtyPath, "preserve me\n")
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.rebuild("dirty-drifted-review", undefined, root),
+					),
+				),
+			),
+		).rejects.toThrow("checkout has uncommitted changes")
+		expect(await Bun.file(dirtyPath).text()).toBe("preserve me\n")
+	})
+
 	test("restores removed worktrees when rebuild creation fails", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/WorktreeService.ts

@@ -254,11 +254,13 @@ const originRef = (ref: string) =>
 interface MaterializeOptions extends BaseCommandOptions {
 	readonly force?: boolean
 	readonly lockHeld?: boolean
+	readonly allowReferenceDrift?: boolean
 }
 
 interface RemoveOptions extends BaseCommandOptions {
 	readonly snapshots?: WorktreeRemovalSnapshot[]
 	readonly lockHeld?: boolean
+	readonly allowReferenceDrift?: boolean
 }
 
 interface LifecycleOptions extends BaseCommandOptions {
@@ -1010,12 +1012,32 @@ const materializeJj = (options: {
 					})
 				}
 				if (exists && registered) {
+					const actualCommit = yield* backend.workspaceHead(workspacePath)
+					if ("ref" in checkout) {
+						const expectedCommit = yield* backend.resolveRevision(
+							repositoryPath,
+							checkout.ref,
+						)
+						if (!expectedCommit) {
+							return yield* new WorktreeError({
+								message: `Reference '${checkout.ref}' for repository '${checkout.repo}' does not resolve to a commit; run 'agency repo fetch ${checkout.repo}' and retry`,
+							})
+						}
+						if (
+							actualCommit !== expectedCommit &&
+							!options.commandOptions.allowReferenceDrift
+						) {
+							return yield* new WorktreeError({
+								message: `Existing checkout ${workspacePath} does not match reference '${checkout.ref}' (${expectedCommit})`,
+							})
+						}
+					}
 					reports.push({
 						repo: checkout.repo,
 						kind: "branch" in checkout ? "writable" : "reference",
 						path: workspacePath,
 						requestedRef: "branch" in checkout ? checkout.branch : checkout.ref,
-						resolvedCommit: yield* backend.workspaceHead(workspacePath),
+						resolvedCommit: actualCommit,
 						action: "reused",
 					})
 					continue
@@ -1221,6 +1243,9 @@ const removeJj = (
 				.filter(
 					(conflict) =>
 						conflict.kind !== "stale-registration" &&
+						!(
+							options.allowReferenceDrift && conflict.kind === "reference-drift"
+						) &&
 						!(
 							conflict.kind === "unregistered-checkout" &&
 							recoverable.has(checkout.path)
@@ -2392,7 +2417,12 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 										root,
 									)
 									const blockingConflicts = inspection.conflicts.filter(
-										(conflict) => conflict.kind !== "stale-registration",
+										(conflict) =>
+											conflict.kind !== "stale-registration" &&
+											!(
+												options.allowReferenceDrift &&
+												conflict.kind === "reference-drift"
+											),
 									)
 									if (blockingConflicts.length > 0) {
 										return yield* new WorktreeError({
@@ -2723,21 +2753,29 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						)
 					}
 					const inspection = yield* inspectExecution(taskId, phaseId, root)
-					const dirty = inspection.checkouts.filter(
-						(checkout) => checkout.dirty === true,
+					const notProvablyClean = inspection.checkouts.filter(
+						(checkout) => checkout.exists && checkout.dirty !== false,
 					)
-					if (dirty.length > 0) {
+					if (notProvablyClean.length > 0) {
+						const unknown = notProvablyClean.some(
+							(checkout) => checkout.dirty === null,
+						)
 						return yield* new WorktreeError({
-							message: `Cannot rebuild ${dirty.map((checkout) => checkout.path).join(", ")}; checkout has uncommitted changes`,
-							conflicts: dirty.flatMap((checkout) => checkout.conflicts),
+							message: `Cannot rebuild ${notProvablyClean.map((checkout) => checkout.path).join(", ")}; ${unknown ? "checkout cleanliness could not be verified" : "checkout has uncommitted changes"}`,
+							conflicts: notProvablyClean.flatMap(
+								(checkout) => checkout.conflicts,
+							),
 						})
 					}
-					if (inspection.conflicts.length > 0) {
+					const blockingConflicts = inspection.conflicts.filter(
+						(conflict) => conflict.kind !== "reference-drift",
+					)
+					if (blockingConflicts.length > 0) {
 						return yield* new WorktreeError({
-							message: inspection.conflicts
+							message: blockingConflicts
 								.map(({ message }) => message)
 								.join("\n"),
-							conflicts: inspection.conflicts,
+							conflicts: blockingConflicts,
 						})
 					}
 					yield* service.materialize(taskId, phaseId, inspection.root, {
@@ -2745,6 +2783,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						dryRun: true,
 						silent: true,
 						lockHeld: true,
+						allowReferenceDrift: true,
 					})
 					if (options.dryRun) {
 						return {
@@ -2768,6 +2807,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							...options,
 							snapshots,
 							lockHeld: true,
+							allowReferenceDrift: true,
 						},
 					)
 					const workspace = yield* service