@markjaquith/agency 2.73.1 → 2.73.2

package/package.json

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

package/src/services/RepositoryService.test.ts

@@ -212,6 +212,13 @@ status: working
 			"main",
 		])
 		await Bun.write(join(checkout, "dirty.txt"), "preserved\n")
+		await runGit([
+			"-C",
+			target,
+			"update-ref",
+			"refs/agency/reviews/active",
+			"main",
+		])
 
 		const result = await runTestEffect(
 			RepositoryService.pipe(
@@ -238,6 +245,96 @@ status: working
 		expect(await Bun.file(join(root, "tasks/active/TASK.md")).text()).toContain(
 			"repo: linked",
 		)
+		expect(
+			await gitOutput([
+				"--git-dir",
+				join(root, "repos/linked"),
+				"rev-parse",
+				"refs/agency/reviews/active",
+			]),
+		).toBe(await gitOutput(["-C", target, "rev-parse", "main"]))
+	})
+
+	test("preserves detached registered worktree commits from a shallow linked repository", async () => {
+		const upstream = join(root, "upstream")
+		const target = join(root, "shallow-linked-repository")
+		const checkout = join(root, "tasks/detached/code/linked")
+		await runGit(["init", "--bare", "--initial-branch=main", upstream])
+		const seed = join(root, "seed")
+		await runGit(["clone", upstream, seed])
+		await runGit(["-C", seed, "config", "user.email", "test@example.com"])
+		await runGit(["-C", seed, "config", "user.name", "Test"])
+		await Bun.write(join(seed, "README.md"), "shallow\n")
+		await runGit(["-C", seed, "add", "README.md"])
+		await runGit(["-C", seed, "commit", "-m", "initial"])
+		await runGit(["-C", seed, "push", "origin", "main"])
+		await runGit(["clone", "--depth=1", `file://${upstream}`, target])
+		await runGit(["-C", target, "config", "user.email", "test@example.com"])
+		await runGit(["-C", target, "config", "user.name", "Test"])
+		await runGit([
+			"-C",
+			target,
+			"remote",
+			"set-url",
+			"origin",
+			portableRemote("shallow-materialized"),
+		])
+		await mkdir(dirname(checkout), { recursive: true })
+		await runGit([
+			"-C",
+			target,
+			"worktree",
+			"add",
+			"--detach",
+			checkout,
+			"main",
+		])
+		await Bun.write(join(checkout, "detached.txt"), "preserved\n")
+		await runGit(["-C", checkout, "add", "detached.txt"])
+		await runGit(["-C", checkout, "commit", "-m", "detached work"])
+		const detachedCommit = await gitOutput([
+			"-C",
+			checkout,
+			"rev-parse",
+			"HEAD",
+		])
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.link("linked", target, root)),
+			),
+		)
+
+		await runTestEffect(
+			RepositoryService.pipe(
+				Effect.flatMap((service) => service.materialize("linked", root)),
+			),
+		)
+
+		expect(await gitOutput(["-C", checkout, "rev-parse", "HEAD"])).toBe(
+			detachedCommit,
+		)
+		expect(await Bun.file(join(checkout, "detached.txt")).text()).toBe(
+			"preserved\n",
+		)
+		expect(
+			await gitOutput(["-C", checkout, "rev-parse", "--git-common-dir"]),
+		).toBe(await realpath(join(root, "repos/linked")))
+		await runGit([
+			"--git-dir",
+			join(root, "repos/linked"),
+			"cat-file",
+			"-e",
+			`${detachedCommit}^{commit}`,
+		])
+		expect(
+			await gitOutput([
+				"--git-dir",
+				join(root, "repos/linked"),
+				"for-each-ref",
+				"--format=%(refname)",
+				"refs/agency/materialize/",
+			]),
+		).toBe("")
 	})
 
 	test("materializes an alias linked through an existing worktree", async () => {

package/src/services/RepositoryService.ts

@@ -19,6 +19,7 @@ import {
 import { documentRevision } from "../workbase/document-revision"
 import {
 	VersionControlService,
+	type RegisteredWorkspace,
 	type VersionControlBackend,
 } from "./VersionControlService"
 
@@ -558,9 +559,9 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 
 					const source = yield* fs.realPath(repository.path)
 					const registered = yield* backend.listWorkspaces(repository.path)
-					const registeredPaths = registered
-						.map((workspace) => workspace.path)
-						.sort()
+					const registeredState = registered
+						.map(({ path, commit, branch }) => ({ path, commit, branch }))
+						.sort((left, right) => left.path.localeCompare(right.path))
 					const worktrees: (typeof registered)[number][] = []
 					for (const workspace of registered) {
 						if (!(yield* fs.isDirectory(workspace.path))) {
@@ -634,6 +635,77 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 							),
 						),
 					)
+					const reviewRefs = yield* fs.runCommand(
+						[
+							"git",
+							"-C",
+							source,
+							"for-each-ref",
+							"--format=%(refname)",
+							"refs/agency/reviews/",
+						],
+						{ captureOutput: true },
+					)
+					if (reviewRefs.exitCode !== 0) {
+						yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+						return yield* new RepositoryError({
+							message: `Failed to enumerate Agency review refs while materializing repository '${alias}'`,
+						})
+					}
+					const preservedReviewRefs = reviewRefs.stdout
+						.split("\n")
+						.map((ref) => ref.trim())
+						.filter(Boolean)
+					const worktreeCommits = [
+						...new Set(
+							worktrees
+								.map((workspace) => workspace.commit)
+								.filter((commit): commit is string => commit !== null),
+						),
+					]
+					const temporaryRefs = worktreeCommits.map(
+						(_, index) =>
+							`refs/agency/materialize/${suffix}/${String(index).padStart(4, "0")}`,
+					)
+					const preservationRefspecs = [
+						...preservedReviewRefs.map((ref) => `+${ref}:${ref}`),
+						...worktreeCommits.map(
+							(commit, index) => `+${commit}:${temporaryRefs[index]}`,
+						),
+					]
+					if (preservationRefspecs.length > 0) {
+						const preserved = yield* fs.runCommand(
+							[
+								"git",
+								"--git-dir",
+								staging,
+								"fetch",
+								"--no-tags",
+								"--no-write-fetch-head",
+								source,
+								...preservationRefspecs,
+							],
+							{ captureOutput: true },
+						)
+						if (preserved.exitCode !== 0) {
+							yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+							return yield* new RepositoryError({
+								message: `Failed to preserve Agency refs and registered worktree commits while materializing repository '${alias}': ${preserved.stderr.trim()}`,
+							})
+						}
+						for (const ref of temporaryRefs) {
+							const removed = yield* fs.runCommand(
+								["git", "--git-dir", staging, "update-ref", "-d", ref],
+								{ captureOutput: true },
+							)
+							if (removed.exitCode !== 0) {
+								yield* fs.deleteDirectory(staging).pipe(Effect.ignore)
+								return yield* new RepositoryError({
+									message: `Failed to remove temporary materialization ref '${ref}' for repository '${alias}': ${removed.stderr.trim()}`,
+								})
+							}
+						}
+					}
 					yield* backend
 						.setRemoteUrl(staging, "origin", repository.declaredRemote)
 						.pipe(
@@ -728,16 +800,16 @@ export class RepositoryService extends Effect.Service<RepositoryService>()(
 									.pipe(
 										Effect.provideService(FileSystemService, fs),
 									) as unknown as Effect.Effect<
-									readonly { readonly path: string }[],
+									readonly RegisteredWorkspace[],
 									unknown,
 									never
 								>,
 							)
-							const currentPaths = current
-								.map((workspace) => workspace.path)
-								.sort()
+							const currentState = current
+								.map(({ path, commit, branch }) => ({ path, commit, branch }))
+								.sort((left, right) => left.path.localeCompare(right.path))
 							if (
-								JSON.stringify(currentPaths) !== JSON.stringify(registeredPaths)
+								JSON.stringify(currentState) !== JSON.stringify(registeredState)
 							)
 								throw new Error(
 									`Git worktree registrations changed during materialization`,