@markjaquith/agency 2.69.0 → 2.69.1

package/package.json

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

package/src/services/SyncService.test.ts

@@ -575,6 +575,8 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 	})
 
 	test("materializes missing workspaces but leaves branch conflicts unresolved", async () => {
+		await Bun.write(join(root, "bin", "gh"), "#!/bin/sh\nprintf '[]\\n'\n")
+		await chmod(join(root, "bin", "gh"), 0o755)
 		for (const [id, branch] of [
 			["missing", "feat/missing"],
 			["conflict", "feat/conflict"],
@@ -649,6 +651,158 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 		).toBe(false)
 	})
 
+	test("reconciles a recorded merged PR without materializing an absent checkout", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "recorded-merged",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/example",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await git(
+			["remote", "set-url", "origin", "git@github.com:example/agency.git"],
+			join(root, "repos/agency"),
+		)
+		await runTestEffect(
+			PullRequestService.pipe(
+				Effect.flatMap((service) =>
+					service.setUrl(
+						"recorded-merged",
+						undefined,
+						"https://github.com/example/agency/pull/42",
+						root,
+					),
+				),
+			),
+		)
+
+		const applied = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({
+						cwd: root,
+						apply: true,
+						taskId: "recorded-merged",
+					}),
+				),
+			),
+		)
+		expect(applied.changes.map((change) => change.kind)).toEqual([
+			"record-pr",
+			"mark-done",
+		])
+		expect(applied.executions[0]?.checkouts).toEqual([])
+		expect(
+			await Bun.file(join(root, "tasks/recorded-merged/code/agency")).exists(),
+		).toBe(false)
+	})
+
+	test("reconciles a uniquely discovered merged PR without materializing", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "discovered-merged",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/example",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await git(
+			["remote", "set-url", "origin", "git@github.com:example/agency.git"],
+			join(root, "repos/agency"),
+		)
+
+		const applied = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({
+						cwd: root,
+						apply: true,
+						taskId: "discovered-merged",
+					}),
+				),
+			),
+		)
+		expect(applied.changes.map((change) => change.kind)).toEqual([
+			"record-pr",
+			"mark-done",
+		])
+		expect(applied.executions[0]?.checkouts).toEqual([])
+		expect(
+			await Bun.file(
+				join(root, "tasks/discovered-merged/code/agency"),
+			).exists(),
+		).toBe(false)
+	})
+
+	test("materializes when discovered PR evidence is ambiguous", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "ambiguous",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/example",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const gh = await Bun.file(join(root, "bin", "gh")).text()
+		await Bun.write(
+			join(root, "bin", "gh"),
+			gh
+				.replace('[{"number":42', '[{"number":42')
+				.replace(
+					"]\nJSON\n",
+					`,{\"number\":43,\"state\":\"MERGED\",\"title\":\"Ship again\",\"isDraft\":false,\"headRefName\":\"feat/example\",\"baseRefName\":\"main\",\"headRepository\":{\"nameWithOwner\":\"example/agency\"},\"url\":\"https://github.com/example/agency/pull/43\",\"mergedAt\":\"2100-01-01T00:00:00Z\",\"mergeCommit\":{\"oid\":\"def\"},\"mergeable\":\"MERGEABLE\"}]\nJSON\n`,
+				),
+		)
+
+		const applied = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({
+						cwd: root,
+						apply: true,
+						taskId: "ambiguous",
+					}),
+				),
+			),
+		)
+		expect(applied.unresolved).toContainEqual(
+			expect.objectContaining({ kind: "multiple-prs" }),
+		)
+		expect(applied.changes).toContainEqual(
+			expect.objectContaining({ kind: "materialize-workspace" }),
+		)
+		expect(
+			await Bun.file(
+				join(root, "tasks/ambiguous/code/agency/README.md"),
+			).text(),
+		).toBe("example\n")
+	})
+
 	test("leaves a missing checkout registration unresolved", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/SyncService.ts

@@ -162,6 +162,46 @@ const commandErrorSummary = (stderr: string, fallback: string) =>
 		.map((line) => line.trim())
 		.find(Boolean) ?? fallback
 
+interface PullRequestQuery {
+	readonly remoteUrl: string | null
+	readonly remoteRepository: string
+	readonly result:
+		| {
+				readonly exitCode: number
+				readonly stdout: string
+				readonly stderr: string
+		  }
+		| undefined
+}
+
+const mergedPullRequestFromGitHub = (
+	data: ExecutionData,
+	query: PullRequestQuery | undefined,
+) => {
+	if (!query?.result || query.result.exitCode !== 0) return null
+	const existing = data.pr ? normalizePullRequestRecord(data.pr) : null
+	const details = existing
+		? [parseJson<Record<string, unknown>>(query.result.stdout, {})]
+		: parseJson<Record<string, unknown>[]>(query.result.stdout, []).filter(
+				(item) =>
+					item.headRefName === data.branch && item.baseRefName === data.base,
+			)
+	if (details.length !== 1) return null
+	const current = recordFromGitHubJson(details[0]!)
+	if (
+		current.merged !== true ||
+		current.headRepository?.toLowerCase() !==
+			query.remoteRepository.toLowerCase() ||
+		current.headBranch !== data.branch ||
+		current.baseRepository?.toLowerCase() !==
+			current.repository.toLowerCase() ||
+		current.baseBranch !== data.base
+	) {
+		return null
+	}
+	return current
+}
+
 export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 	sync: () => ({
 		reconcile: (
@@ -463,6 +503,14 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					let revision = record.revision
 					const codePath = join(dirname(record.path), "code")
 					const checkoutStates: CheckoutState[] = []
+					const query = prQueries.get(record.key)
+					const remoteMergedPr = config.delivery
+						? null
+						: mergedPullRequestFromGitHub(data, query)
+					const skipCheckoutReconciliation =
+						remoteMergedPr !== null &&
+						data.claim?.state !== "active" &&
+						!data.completion
 					let materialize = false
 					let workspaceConflict = false
 					const declared: readonly (
@@ -473,7 +521,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						...(data.repos ?? []),
 					]
 
-					for (const checkout of declared) {
+					for (const checkout of skipCheckoutReconciliation ? [] : declared) {
 						const repositoryPath = join(root, "repos", checkout.repo)
 						const checkoutPath = join(codePath, checkout.repo)
 						const kind = "branch" in checkout ? "writable" : "reference"
@@ -811,7 +859,11 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						state: "none",
 					}
 					let prConflict = false
-					const query = prQueries.get(record.key)!
+					if (!query) {
+						return yield* new SyncError({
+							message: `Missing pull request query for '${record.key}'`,
+						})
+					}
 					const { remoteUrl, remoteRepository } = query
 
 					if (config.delivery && !remoteUrl) {