@markjaquith/agency 2.61.0 → 2.61.2

package/package.json

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

package/src/cli.test.ts

@@ -1,4 +1,11 @@
-import { afterAll, afterEach, describe, expect, test } from "bun:test"
+import {
+	afterAll,
+	afterEach,
+	describe,
+	expect,
+	setDefaultTimeout,
+	test,
+} from "bun:test"
 import { access, chmod, mkdir, realpath, stat, symlink } from "node:fs/promises"
 import { join, sep } from "node:path"
 import errorFixture from "../fixtures/protocol/error.json"
@@ -9,6 +16,8 @@ const projectRoot = join(import.meta.dir, "..")
 const cliPath = join(projectRoot, "cli.ts")
 const isolatedConfigHome = await createTempDir()
 
+setDefaultTimeout(15_000)
+
 afterAll(() => cleanupTempDir(isolatedConfigHome))
 
 interface CliResult {

package/src/commands/sync.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 { chmod, mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { TaskService } from "../services/TaskService"
 import {
@@ -99,6 +99,44 @@ describe("sync command", () => {
 		})
 	})
 
+	test("groups repeated human-readable warnings by affected target", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "second",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/second",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		const originalPath = process.env.PATH
+		const bin = join(root, "bin")
+		await mkdir(bin)
+		await Bun.write(
+			join(bin, "gh"),
+			'#!/bin/sh\necho "provider unavailable" >&2\nexit 1\n',
+		)
+		await chmod(join(bin, "gh"), 0o755)
+		process.env.PATH = `${bin}:${originalPath}`
+		try {
+			const logs = await captureLogs(() =>
+				runTestEffect(sync({ cwd: root, dryRun: true })),
+			)
+			expect(
+				logs.filter((line) => line.includes("provider unavailable")),
+			).toEqual(["Warning 'task:example', 'task:second': provider unavailable"])
+		} finally {
+			process.env.PATH = originalPath
+		}
+	})
+
 	test("reports human-readable progress without polluting JSON output", async () => {
 		const updates: string[] = []
 		const progress: Progress = {

package/src/commands/sync.ts

@@ -8,6 +8,27 @@ interface SyncCommandOptions extends BaseCommandOptions {
 	readonly dryRun?: boolean
 }
 
+interface Notice {
+	readonly kind: string
+	readonly target: string
+	readonly message: string
+	readonly action?: string
+}
+
+const groupedNotices = <T extends Notice>(notices: readonly T[]) => {
+	const groups = new Map<string, { notice: T; targets: string[] }>()
+	for (const notice of notices) {
+		const key = JSON.stringify([notice.kind, notice.message, notice.action])
+		const group = groups.get(key)
+		if (group) group.targets.push(notice.target)
+		else groups.set(key, { notice, targets: [notice.target] })
+	}
+	return groups.values()
+}
+
+const formatTargets = (targets: readonly string[]) =>
+	targets.map((target) => `'${target}'`).join(", ")
+
 export const sync = (
 	options: SyncCommandOptions = {},
 	progress: Progress = createProgress({
@@ -62,9 +83,11 @@ export const sync = (
 				`${change.status === "applied" ? "Applied" : "Planned"} ${change.kind} '${change.target}': ${change.message}`,
 			)
 		}
-		for (const warning of result.warnings) {
+		for (const { notice: warning, targets } of groupedNotices(
+			result.warnings,
+		)) {
 			log(
-				`Warning '${warning.target}': ${warning.message}${warning.action ? `. ${warning.action}` : ""}`,
+				`Warning ${formatTargets(targets)}: ${warning.message}${warning.action ? `. ${warning.action}` : ""}`,
 			)
 		}
 		for (const issue of result.repositories.unresolved) {
@@ -72,9 +95,11 @@ export const sync = (
 				`Unresolved repository '${issue.alias}': ${issue.message}. ${issue.action}`,
 			)
 		}
-		for (const issue of result.unresolved) {
+		for (const { notice: issue, targets } of groupedNotices(
+			result.unresolved,
+		)) {
 			log(
-				`Unresolved '${issue.target}': ${issue.message}${issue.action ? `. ${issue.action}` : ""}`,
+				`Unresolved ${formatTargets(targets)}: ${issue.message}${issue.action ? `. ${issue.action}` : ""}`,
 			)
 		}
 		if (

package/src/services/PullRequestService.ts

@@ -239,7 +239,15 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 							})
 							if (!url)
 								throw new Error("GitHub CLI did not return a pull request URL")
-							return { ...normalizePullRequestRecord(url), draft }
+							const normalized = normalizePullRequestRecord(url)
+							return {
+								...normalized,
+								headRepository: repository,
+								headBranch: execution.branch,
+								baseRepository: normalized.repository,
+								baseBranch: execution.base,
+								draft,
+							}
 						},
 						catch: (cause) =>
 							new PullRequestError({
@@ -249,7 +257,8 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					if (
 						config.delivery &&
 						(record.provider !== config.delivery.provider ||
-							record.repository.toLowerCase() !== repository.toLowerCase())
+							(record.headRepository ?? record.repository).toLowerCase() !==
+								repository.toLowerCase())
 					) {
 						return yield* new PullRequestError({
 							message:

package/src/services/SyncService.test.ts

@@ -64,14 +64,17 @@ case "$*" in
 *mergeable*) ;;
 *) echo "mergeable field was not requested" >&2; exit 2 ;;
 esac
+case "$*" in
+*baseRepository*) echo "unsupported baseRepository field was requested" >&2; exit 3 ;;
+esac
 if [ "$2" = "view" ]; then
 cat <<'JSON'
-{"number":42,"state":"MERGED","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","url":"https://github.com/example/agency/pull/42","mergedAt":"2100-01-01T00:00:00Z","mergeCommit":{"oid":"abc"},"mergeable":"MERGEABLE"}
+{"number":42,"state":"MERGED","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","headRepository":{"nameWithOwner":"example/agency"},"url":"https://github.com/example/agency/pull/42","mergedAt":"2100-01-01T00:00:00Z","mergeCommit":{"oid":"abc"},"mergeable":"MERGEABLE"}
 JSON
 exit 0
 fi
 cat <<'JSON'
-[{"number":42,"state":"MERGED","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","url":"https://github.com/example/agency/pull/42","mergedAt":"2100-01-01T00:00:00Z","mergeCommit":{"oid":"abc"},"mergeable":"MERGEABLE"}]
+[{"number":42,"state":"MERGED","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","headRepository":{"nameWithOwner":"example/agency"},"url":"https://github.com/example/agency/pull/42","mergedAt":"2100-01-01T00:00:00Z","mergeCommit":{"oid":"abc"},"mergeable":"MERGEABLE"}]
 JSON
 `,
 		)
@@ -172,6 +175,7 @@ pr: null
 		)
 		const invocation = await Bun.file(capture).text()
 		expect(invocation).toContain("--repo\n")
+		expect(invocation).not.toContain("baseRepository")
 		expect(invocation).toContain("GIT_DIR=")
 		expect(invocation).toContain(".jj")
 
@@ -307,6 +311,10 @@ pr: null
 				state: "merged",
 				draft: false,
 				merged: true,
+				headRepository: "example/agency",
+				headBranch: "feat/example",
+				baseRepository: "example/agency",
+				baseBranch: "main",
 				mergeable: true,
 			},
 			claim: { state: "released", sessionId: "session-1" },
@@ -357,7 +365,7 @@ pr: null
 			join(root, "bin", "gh"),
 			`#!/bin/sh
 cat <<'JSON'
-{"number":42,"state":"OPEN","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","url":"https://github.com/example/agency/pull/42","mergedAt":null,"mergeCommit":null,"mergeable":"CONFLICTING"}
+{"number":42,"state":"OPEN","title":"Ship","isDraft":false,"headRefName":"feat/example","baseRefName":"main","headRepository":{"nameWithOwner":"example/agency"},"baseRepository":{"nameWithOwner":"example/agency"},"url":"https://github.com/example/agency/pull/42","mergedAt":null,"mergeCommit":null,"mergeable":"CONFLICTING"}
 JSON
 `,
 		)
@@ -747,6 +755,89 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 		expect(task.data).toMatchObject({ status: "open" })
 	})
 
+	test("reconciles a merged upstream PR whose head is the writable fork", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "forked",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "task/polish-readme",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("forked", undefined, root),
+				),
+			),
+		)
+		await git(
+			["remote", "set-url", "origin", "git@github.com:markjaquith/Pasted.git"],
+			join(root, "repos/agency"),
+		)
+		await runTestEffect(
+			PullRequestService.pipe(
+				Effect.flatMap((service) =>
+					service.setUrl(
+						"forked",
+						undefined,
+						"https://github.com/getpasted/pasted/pull/17",
+						root,
+					),
+				),
+			),
+		)
+		await Bun.write(
+			join(root, "bin", "gh"),
+			`#!/bin/sh
+cat <<'JSON'
+{"number":17,"state":"MERGED","title":"Polish README","isDraft":false,"headRefName":"task/polish-readme","baseRefName":"main","headRepository":{"nameWithOwner":"markjaquith/Pasted"},"baseRepository":{"nameWithOwner":"getpasted/pasted"},"url":"https://github.com/getpasted/pasted/pull/17","mergedAt":"2026-08-11T00:00:00Z","mergeCommit":{"oid":"241d45da1115ef685c91a5e6882d118c16801550"},"mergeable":"UNKNOWN"}
+JSON
+`,
+		)
+		await chmod(join(root, "bin", "gh"), 0o755)
+
+		const applied = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({ cwd: root, apply: true }),
+				),
+			),
+		)
+		expect(
+			applied.unresolved.filter((notice) => notice.target === "task:forked"),
+		).toEqual([])
+		expect(applied.changes.map((change) => change.kind)).toEqual([
+			"record-pr",
+			"mark-done",
+		])
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("forked", root)),
+			),
+		)
+		expect(task.data).toMatchObject({
+			status: "done",
+			pr: {
+				repository: "getpasted/pasted",
+				headRepository: "markjaquith/Pasted",
+				headBranch: "task/polish-readme",
+				baseRepository: "getpasted/pasted",
+				baseBranch: "main",
+				state: "merged",
+				merged: true,
+			},
+		})
+	})
+
 	test("leaves non-PR completion unchanged when a matching PR is discoverable", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -926,4 +1017,44 @@ exit 9
 			),
 		).toEqual([])
 	})
+
+	test("keeps pull request query failures concise", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "unavailable",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/unavailable",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await Bun.write(
+			join(root, "bin", "gh"),
+			`#!/bin/sh
+echo "Unknown JSON field: unsupported" >&2
+echo "Available fields:" >&2
+echo "  additions" >&2
+exit 1
+`,
+		)
+		await chmod(join(root, "bin", "gh"), 0o755)
+
+		const result = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) => service.reconcile({ cwd: root })),
+			),
+		)
+		expect(result.warnings).toContainEqual({
+			kind: "pr-discovery-unavailable",
+			target: "task:unavailable",
+			message: "Unknown JSON field: unsupported",
+		})
+	})
 })

package/src/services/SyncService.ts

@@ -153,6 +153,15 @@ const isCommitId = (ref: string) => /^[0-9a-f]{40,64}$/i.test(ref)
 const originRef = (ref: string) =>
 	ref.replace(/^refs\/remotes\/origin\//, "").replace(/^origin\//, "")
 
+const GITHUB_PR_FIELDS =
+	"number,state,title,isDraft,headRefName,baseRefName,headRepository,url,mergedAt,mergeCommit,mergeable"
+
+const commandErrorSummary = (stderr: string, fallback: string) =>
+	stderr
+		.split("\n")
+		.map((line) => line.trim())
+		.find(Boolean) ?? fallback
+
 export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 	sync: () => ({
 		reconcile: (
@@ -349,7 +358,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 											"view",
 											existing.url,
 											"--json",
-											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
+											GITHUB_PR_FIELDS,
 										],
 										{
 											cwd: repositoryPath,
@@ -372,7 +381,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 											"--state",
 											"all",
 											"--json",
-											"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
+											GITHUB_PR_FIELDS,
 										],
 										{
 											cwd: repositoryPath,
@@ -773,19 +782,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 					const query = prQueries.get(record.key)!
 					const { remoteUrl, remoteRepository } = query
 
-					if (
-						existing &&
-						remoteRepository.toLowerCase() !== existing.repository.toLowerCase()
-					) {
-						prConflict = true
-						unresolved.push({
-							kind: "pr-repository-conflict",
-							target: record.key,
-							message: `Recorded PR repository does not match writable repository remote '${remoteName}'`,
-							action: "Correct the configured remote or recorded PR",
-						})
-					}
-
 					if (config.delivery && !remoteUrl) {
 						warnings.push({
 							kind: "delivery-remote-unavailable",
@@ -812,8 +808,9 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							} else if (
 								parsed.right &&
 								(parsed.right.provider !== config.delivery.provider ||
-									parsed.right.repository.toLowerCase() !==
-										remoteRepository.toLowerCase())
+									(
+										parsed.right.headRepository ?? parsed.right.repository
+									).toLowerCase() !== remoteRepository.toLowerCase())
 							) {
 								if (parsed.right) {
 									prConflict = true
@@ -836,8 +833,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							warnings.push({
 								kind: existing ? "pr-unavailable" : "pr-discovery-unavailable",
 								target: record.key,
-								message:
-									queried.stderr.trim() || "Could not query delivery provider",
+								message: commandErrorSummary(
+									queried.stderr,
+									"Could not query delivery provider",
+								),
 							})
 						}
 					} else if (existing) {
@@ -850,14 +849,18 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							current = recordFromGitHubJson(detail)
 							pr = { ...detail, ...current }
 							if (
-								detail.headRefName !== data.branch ||
-								detail.baseRefName !== data.base
+								current.headRepository?.toLowerCase() !==
+									remoteRepository.toLowerCase() ||
+								current.headBranch !== data.branch ||
+								current.baseRepository?.toLowerCase() !==
+									current.repository.toLowerCase() ||
+								current.baseBranch !== data.base
 							) {
 								prConflict = true
 								unresolved.push({
-									kind: "pr-branch-conflict",
+									kind: "pr-repository-conflict",
 									target: record.key,
-									message: `Recorded PR branches do not match '${data.branch}' -> '${data.base}'`,
+									message: `Recorded PR head does not match '${remoteRepository}:${data.branch}' or base '${current.repository}:${data.base}'`,
 									action: "Correct the declaration or recorded PR URL",
 								})
 							}
@@ -866,7 +869,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							warnings.push({
 								kind: "pr-unavailable",
 								target: record.key,
-								message: `Could not inspect ${existing.url}: ${viewed.stderr.trim()}`,
+								message: `Could not inspect ${existing.url}: ${commandErrorSummary(viewed.stderr, "GitHub query failed")}`,
 							})
 						}
 					} else {
@@ -883,6 +886,20 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							if (matches.length === 1) {
 								current = recordFromGitHubJson(matches[0]!)
 								pr = { ...matches[0], ...current }
+								if (
+									current.headRepository?.toLowerCase() !==
+										remoteRepository.toLowerCase() ||
+									current.baseRepository?.toLowerCase() !==
+										current.repository.toLowerCase()
+								) {
+									prConflict = true
+									unresolved.push({
+										kind: "pr-repository-conflict",
+										target: record.key,
+										message: `Discovered PR repositories do not match writable repository '${remoteRepository}' and base '${current.repository}'`,
+										action: "Record the authoritative PR URL manually",
+									})
+								}
 							} else if (matches.length > 1) {
 								unresolved.push({
 									kind: "multiple-prs",
@@ -895,8 +912,10 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							warnings.push({
 								kind: "pr-discovery-unavailable",
 								target: record.key,
-								message:
-									listed.stderr.trim() || "Could not discover pull requests",
+								message: commandErrorSummary(
+									listed.stderr,
+									"Could not discover pull requests",
+								),
 							})
 						}
 					}

package/src/workbase/delivery-command.test.ts

@@ -104,8 +104,24 @@ describe("delivery commands", () => {
 			isDraft: false,
 		}
 		expect(
-			recordFromGitHubJson({ ...base, state: "OPEN", mergeable: "MERGEABLE" }),
-		).toMatchObject({ state: "open", merged: false, mergeable: true })
+			recordFromGitHubJson({
+				...base,
+				state: "OPEN",
+				headRefName: "feat/example",
+				baseRefName: "main",
+				headRepository: { nameWithOwner: "fork/agency" },
+				baseRepository: { nameWithOwner: "example/agency" },
+				mergeable: "MERGEABLE",
+			}),
+		).toMatchObject({
+			state: "open",
+			merged: false,
+			headRepository: "fork/agency",
+			headBranch: "feat/example",
+			baseRepository: "example/agency",
+			baseBranch: "main",
+			mergeable: true,
+		})
 		expect(
 			recordFromGitHubJson({
 				...base,

package/src/workbase/delivery-command.ts

@@ -156,11 +156,24 @@ export const recordFromGitHubUrl = (url: string): PullRequestRecord => {
 export const recordFromGitHubJson = (value: Record<string, unknown>) => {
 	const url = typeof value.url === "string" ? value.url : ""
 	const record = recordFromGitHubUrl(url)
+	const repositoryName = (repository: unknown) => {
+		if (!repository || typeof repository !== "object") return undefined
+		const nameWithOwner = (repository as Record<string, unknown>).nameWithOwner
+		return typeof nameWithOwner === "string" && nameWithOwner
+			? nameWithOwner
+			: undefined
+	}
 	const githubState = String(value.state ?? "OPEN").toLowerCase()
 	const merged = githubState === "merged" || value.mergedAt != null
 	const mergeable = String(value.mergeable ?? "UNKNOWN").toLowerCase()
 	return {
 		...record,
+		headRepository: repositoryName(value.headRepository),
+		headBranch:
+			typeof value.headRefName === "string" ? value.headRefName : undefined,
+		baseRepository: repositoryName(value.baseRepository) ?? record.repository,
+		baseBranch:
+			typeof value.baseRefName === "string" ? value.baseRefName : undefined,
 		state: merged ? "merged" : githubState === "closed" ? "closed" : "open",
 		draft: value.isDraft === true,
 		merged,

package/src/workbase/schemas.ts

@@ -72,6 +72,10 @@ const GitHubPullRequestUrl = NonEmptyString.pipe(
 export const PullRequestRecord = Schema.Struct({
 	provider: EntityId,
 	repository: NonEmptyString,
+	headRepository: Schema.optional(NonEmptyString),
+	headBranch: Schema.optional(NonEmptyString),
+	baseRepository: Schema.optional(NonEmptyString),
+	baseBranch: Schema.optional(NonEmptyString),
 	identifier: NonEmptyString,
 	url: Url,
 	state: Schema.Literal("open", "closed", "merged"),