@markjaquith/agency 2.58.0 → 2.58.2

package/package.json

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

package/src/services/ArchiveService.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 { ArchiveService } from "./ArchiveService"
@@ -22,6 +22,17 @@ const git = async (args: string[], cwd?: string) => {
 	}
 }
 
+const jj = async (args: string[]) => {
+	const process = Bun.spawn(["jj", ...args], {
+		stdout: "pipe",
+		stderr: "pipe",
+	})
+	await process.exited
+	if (process.exitCode !== 0) {
+		throw new Error(await new Response(process.stderr).text())
+	}
+}
+
 describe("ArchiveService", () => {
 	let root: string
 	const dropTask = (id: string) =>
@@ -265,6 +276,166 @@ describe("ArchiveService", () => {
 		).toBe(0)
 	})
 
+	test("retries archive after a jj workspace was forgotten but not deleted", 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: "interrupted",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/interrupted",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("interrupted", "dropped", root),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("interrupted", undefined, root),
+				),
+			),
+		)
+		await jj([
+			"-R",
+			repository,
+			"workspace",
+			"forget",
+			"agency-interrupted-task-agency",
+		])
+
+		const preview = await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) =>
+					service.archiveTask("interrupted", root, { dryRun: true }),
+				),
+			),
+		)
+		expect(preview.removedWorktrees).toEqual([workspace.writablePath!])
+
+		await runTestEffect(
+			ArchiveService.pipe(
+				Effect.flatMap((service) => service.archiveTask("interrupted", root)),
+			),
+		)
+		expect(await Bun.file(workspace.writablePath!).exists()).toBe(false)
+		expect(
+			await Bun.file(join(root, "archive/tasks/interrupted/TASK.md")).exists(),
+		).toBe(true)
+	})
+
+	test("refuses a modified residual jj checkout after workspace removal", 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: "modified-residual",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/modified-residual",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("modified-residual", "dropped", root),
+				),
+			),
+		)
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("modified-residual", undefined, root),
+				),
+			),
+		)
+		await jj([
+			"-R",
+			repository,
+			"workspace",
+			"forget",
+			"agency-modified-residual-task-agency",
+		])
+		await Bun.write(join(workspace.writablePath!, "keep.txt"), "keep me\n")
+
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("modified-residual", root),
+					),
+				),
+			),
+		).rejects.toThrow("contents do not match expected revision")
+		expect(
+			await Bun.file(join(workspace.writablePath!, "keep.txt")).text(),
+		).toBe("keep me\n")
+		expect(
+			await Bun.file(join(root, "tasks/modified-residual/TASK.md")).exists(),
+		).toBe(true)
+		expect(
+			await Bun.file(
+				join(
+					root,
+					`.agency-worktree-${Buffer.from("modified-residual:task").toString("hex")}.lock`,
+				),
+			).exists(),
+		).toBe(false)
+
+		await rm(join(workspace.writablePath!, "keep.txt"))
+		await rm(join(workspace.writablePath!, ".jj"), {
+			recursive: true,
+			force: true,
+		})
+		await expect(
+			runTestEffect(
+				ArchiveService.pipe(
+					Effect.flatMap((service) =>
+						service.archiveTask("modified-residual", root),
+					),
+				),
+			),
+		).rejects.toThrow("is not registered as a jj workspace")
+		expect(
+			await Bun.file(join(workspace.writablePath!, "README.md")).exists(),
+		).toBe(true)
+	})
+
 	test("archives a phase in the mirrored task hierarchy", async () => {
 		await runTestEffect(
 			TaskService.pipe(

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 {
@@ -770,6 +772,81 @@ const jjWorkspaceName = (
 	repo: string,
 ) => `agency-${taskId}-${phaseId ?? "task"}-${repo}`
 
+// A process can stop after `jj workspace forget` but before checkout deletion.
+// Only recover that residual when its repository and complete tree still match.
+const inspectJjResidual = (
+	root: string,
+	repositoryPath: string,
+	workspacePath: string,
+	revision: string,
+) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const repoPointer = join(workspacePath, ".jj", "repo")
+		if (!(yield* fs.exists(repoPointer))) return "unowned" as const
+
+		const pointer = (yield* fs.readFile(repoPointer)).trim()
+		if (!pointer) return "unowned" as const
+		const linkedRepository = resolve(dirname(repoPointer), pointer)
+		const expectedRepository = join(repositoryPath, ".jj", "repo")
+		if (
+			!(yield* fs.exists(linkedRepository)) ||
+			(yield* fs.realPath(linkedRepository)) !==
+				(yield* fs.realPath(expectedRepository))
+		)
+			return "unowned" as const
+
+		const comparisonPath = join(
+			root,
+			`.agency-jj-residual-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+		)
+		const comparisonName = basename(comparisonPath)
+		return yield* Effect.gen(function* () {
+			const created = yield* fs.runCommand(
+				[
+					"jj",
+					"-R",
+					repositoryPath,
+					"workspace",
+					"add",
+					"--name",
+					comparisonName,
+					"-r",
+					revision,
+					comparisonPath,
+				],
+				{ captureOutput: true },
+			)
+			if (created.exitCode !== 0) {
+				return yield* new WorktreeError({
+					message: `Cannot verify unregistered jj checkout ${workspacePath}: ${created.stderr}`,
+				})
+			}
+			const comparison = yield* fs.runCommand(
+				["diff", "-qr", "-x", ".jj", workspacePath, comparisonPath],
+				{ captureOutput: true },
+			)
+			if (comparison.exitCode > 1) {
+				return yield* new WorktreeError({
+					message: `Cannot verify unregistered jj checkout ${workspacePath}: ${comparison.stderr}`,
+				})
+			}
+			return comparison.exitCode === 0
+				? ("clean" as const)
+				: ("modified" as const)
+		}).pipe(
+			Effect.ensuring(
+				Effect.gen(function* () {
+					yield* fs.runCommand(
+						["jj", "-R", repositoryPath, "workspace", "forget", comparisonName],
+						{ captureOutput: true },
+					)
+					yield* fs.deleteDirectory(comparisonPath)
+				}).pipe(Effect.ignore),
+			),
+		)
+	})
+
 const buildInspectionContext = (
 	startPath: string,
 	skipWritableRevisionResolution: boolean,
@@ -935,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
@@ -1103,10 +1200,66 @@ const removeJj = (
 	Effect.gen(function* () {
 		const fs = yield* FileSystemService
 		const versionControl = yield* VersionControlService
+		const tasks = yield* TaskService
+		const phases = yield* PhaseService
 		const backend = yield* versionControl.forWorkbase(root)
 		const inspection = yield* inspectExecution(taskId, phaseId, root)
-		const blocking = inspection.conflicts.filter(
-			(conflict) => conflict.kind !== "stale-registration",
+		const task = yield* tasks.show(taskId, root)
+		const execution =
+			"phases" in task.data && phaseId
+				? (yield* phases.show(taskId, phaseId, root)).data
+				: task.data
+		const recoverable = new Map<string, string>()
+		const modifiedResiduals = new Map<string, string>()
+		for (const checkout of inspection.checkouts) {
+			const recoveryRevision =
+				checkout.expectedCommit ??
+				(checkout.kind === "writable" && "base" in execution
+					? yield* backend.resolveRevision(
+							join(root, "repos", checkout.repo),
+							execution.base,
+						)
+					: null)
+			if (
+				!checkout.conflicts.some(
+					(conflict) => conflict.kind === "unregistered-checkout",
+				) ||
+				!recoveryRevision
+			)
+				continue
+			const repositoryPath = join(root, "repos", checkout.repo)
+			const residual = yield* inspectJjResidual(
+				root,
+				repositoryPath,
+				checkout.path,
+				recoveryRevision,
+			)
+			if (residual === "clean") recoverable.set(checkout.path, recoveryRevision)
+			else if (residual === "modified")
+				modifiedResiduals.set(checkout.path, recoveryRevision)
+		}
+		const blocking = inspection.checkouts.flatMap((checkout) =>
+			checkout.conflicts
+				.filter(
+					(conflict) =>
+						conflict.kind !== "stale-registration" &&
+						!(
+							options.allowReferenceDrift && conflict.kind === "reference-drift"
+						) &&
+						!(
+							conflict.kind === "unregistered-checkout" &&
+							recoverable.has(checkout.path)
+						),
+				)
+				.map((conflict) =>
+					conflict.kind === "unregistered-checkout" &&
+					modifiedResiduals.has(checkout.path)
+						? {
+								...conflict,
+								message: `Cannot remove unregistered jj checkout ${checkout.path}; its contents do not match expected revision '${modifiedResiduals.get(checkout.path)}'`,
+							}
+						: conflict,
+				),
 		)
 		if (blocking.length > 0) {
 			return yield* new WorktreeError({
@@ -1121,6 +1274,7 @@ const removeJj = (
 			workspaceName: string
 			head: string
 			branch: string | null
+			registered: boolean
 		}[] = []
 		for (const checkout of inspection.checkouts) {
 			if (checkout.dirty) {
@@ -1128,8 +1282,20 @@ const removeJj = (
 					message: `Failed to remove workspace for '${checkout.repo}': checkout has uncommitted changes`,
 				})
 			}
-			if (!checkout.registeredPath) continue
 			const repositoryPath = join(root, "repos", checkout.repo)
+			if (!checkout.registeredPath) {
+				const recoveryRevision = recoverable.get(checkout.path)
+				if (!recoveryRevision) continue
+				plans.push({
+					repositoryPath,
+					workspacePath: checkout.path,
+					workspaceName: jjWorkspaceName(taskId, phaseId, checkout.repo),
+					head: recoveryRevision,
+					branch: checkout.actualBranch,
+					registered: false,
+				})
+				continue
+			}
 			const registered = (yield* backend.listWorkspaces(repositoryPath)).find(
 				(workspace) => workspace.path === checkout.registeredPath,
 			)
@@ -1144,6 +1310,7 @@ const removeJj = (
 				workspaceName: registered.name,
 				head: checkout.actualCommit,
 				branch: checkout.actualBranch,
+				registered: true,
 			})
 		}
 
@@ -1162,11 +1329,15 @@ const removeJj = (
 		const completed: typeof plans = []
 		return yield* Effect.gen(function* () {
 			for (const plan of plans) {
-				yield* backend.removeWorkspace({
-					repositoryPath: plan.repositoryPath,
-					workspacePath: plan.workspacePath,
-					workspaceName: plan.workspaceName,
-				})
+				if (plan.registered) {
+					yield* backend.removeWorkspace({
+						repositoryPath: plan.repositoryPath,
+						workspacePath: plan.workspacePath,
+						workspaceName: plan.workspaceName,
+					})
+				} else {
+					yield* fs.deleteDirectory(plan.workspacePath)
+				}
 				completed.push(plan)
 			}
 			yield* fs.deleteDirectoryIfEmpty(inspection.codePath)
@@ -2246,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({
@@ -2577,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, {
@@ -2599,6 +2783,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						dryRun: true,
 						silent: true,
 						lockHeld: true,
+						allowReferenceDrift: true,
 					})
 					if (options.dryRun) {
 						return {
@@ -2622,6 +2807,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							...options,
 							snapshots,
 							lockHeld: true,
+							allowReferenceDrift: true,
 						},
 					)
 					const workspace = yield* service