@markjaquith/agency 2.39.1 → 2.40.0

package/README.md

@@ -427,7 +427,7 @@ materializing or pushing. Blocked, done, and dropped targets are rejected unless
 `agency sync` first compares portable repository declarations with local
 materializations, then compares every execution declaration with local branch
 and worktree registration, checkout dirtiness, resolved reference commits, claim
-expiry, and pull request and merge state. It reports
+expiry, and pull request state, merge state, and mergeability. It reports
 structured `changes`, `warnings`, `unresolved`, and per-execution evidence. The
 default and `--dry-run` modes are observational.
 
@@ -437,7 +437,7 @@ default and `--dry-run` modes are observational.
 - adopt legacy materializations only when they have an unambiguous portable origin;
 - materialize missing checkouts when no registration, branch, or path conflicts;
 - release an active claim only after its declared expiry has passed;
-- record a single PR whose head and base match the declaration; and
+- record or refresh a single PR whose head and base match the declaration; and
 - mark work done after its authoritative PR is merged and no active claim remains.
 
 Apply never overwrites linked or invalid repositories, repairs remote drift,

package/package.json

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

package/skills/agency/references/contracts.md

@@ -126,7 +126,9 @@ status: open
 `ticketUrl` belongs to tasks and epics, not phases. `description` is optional but
 must be non-empty when present. `pr` is `null`, a legacy GitHub PR URL, or a
 provider-neutral record containing `provider`, `repository`, `identifier`, `url`,
-`state`, `draft`, and `merged`. New PR creation writes the structured record.
+`state`, `draft`, `merged`, and optional `mergeable`. Mergeability is `true`,
+`false`, or `null` when the provider cannot determine it. New PR creation writes
+the structured record.
 Status is `open`, `working`, `delegated`, `done`, or `dropped`; `delegated` is
 readable legacy state but cannot be newly assigned.
 

package/skills/agency/references/recipes.md

@@ -239,8 +239,9 @@ agency worktree repair <task-id> [phase-id] --dry-run --json
 
 Use `agency sync --apply` only with explicit user intent. It may safely
 materialize an unconflicted missing checkout, release an expired claim, record a
-single matching PR, or mark work done after its authoritative PR merged and no
-claim remains. It never modifies dirty checkouts, switches branches, resets
+single matching PR, refresh recorded PR state and mergeability, or mark work done
+after its authoritative PR merged and no claim remains. It never modifies dirty
+checkouts, switches branches, resets
 references, chooses among PRs, or bypasses active claims.
 
 For a worktree-specific issue, use `worktree repair --dry-run` before repair.

package/src/cli.test.ts

@@ -1019,7 +1019,13 @@ status: open
 				const contract = JSON.parse(printed.stdout)
 				expect(contract.cwd).toBe(launch.cwd)
 				expect(contract.environment.OPENCODE_CONFIG).toBeUndefined()
-				expect(contract.environment.OPENCODE_CONFIG_CONTENT).toBeUndefined()
+				expect(
+					JSON.parse(contract.environment.OPENCODE_CONFIG_CONTENT),
+				).toEqual({
+					permission: {
+						external_directory: { [join(workbaseRoot, "*")]: "allow" },
+					},
+				})
 				const environment = {
 					...process.env,
 					...contract.environment,

package/src/commands/work.test.ts

@@ -45,6 +45,9 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 }
 
 const taskDirectory = "/workbase/tasks/example"
+const workbasePermission = JSON.stringify({
+	permission: { external_directory: { "/workbase/*": "allow" } },
+})
 
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
@@ -487,9 +490,9 @@ describe("work command", () => {
 			cwd: "/workbase/epics/delivery",
 		})
 		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG).toBeUndefined()
-		expect(
-			harness.launchEnvironments[0]?.OPENCODE_CONFIG_CONTENT,
-		).toBeUndefined()
+		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG_CONTENT).toBe(
+			workbasePermission,
+		)
 	})
 
 	test("resolves an existing positional path before treating it as a task ID", async () => {
@@ -915,7 +918,7 @@ describe("work command", () => {
 		expect(harness.taskStatuses.example).toBe("done")
 	})
 
-	test("does not inject runtime OpenCode configuration", async () => {
+	test("grants managed OpenCode launches absolute workbase access", async () => {
 		const harness = createHarness()
 		const output = await captureLogs(() =>
 			harness.run({ taskId: "example", opencode: true, printCommand: true }),
@@ -923,7 +926,7 @@ describe("work command", () => {
 		const printed = JSON.parse(output.join("\n"))
 
 		expect(printed.environment.OPENCODE_CONFIG).toBeUndefined()
-		expect(printed.environment.OPENCODE_CONFIG_CONTENT).toBeUndefined()
+		expect(printed.environment.OPENCODE_CONFIG_CONTENT).toBe(workbasePermission)
 	})
 
 	test("does not override customized OpenCode access policy", async () => {

package/src/commands/work.ts

@@ -122,7 +122,10 @@ export const work = (
 		const inputAllowed = options.inputAllowed ?? true
 		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
 		if (!root) return
-		yield* integrations.sync(root)
+		const integration = yield* integrations.sync(root)
+		const managedOpencode = integration.files.some(
+			(file) => file.name === "opencode" && file.state === "managed",
+		)
 		const { config } = yield* workbase.loadConfig(root)
 
 		let target: WorkTarget | null = null
@@ -331,6 +334,13 @@ export const work = (
 			...resolved.environment,
 			...runnerEnvironment(runner, variables),
 		}
+		if (runner === "opencode" && managedOpencode) {
+			environment.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+				permission: {
+					external_directory: { [join(root, "*")]: "allow" },
+				},
+			})
+		}
 		if (options.printCommand) {
 			log(
 				JSON.stringify(

package/src/services/SyncService.test.ts

@@ -46,14 +46,18 @@ describe("SyncService", () => {
 		await Bun.write(
 			gh,
 			`#!/bin/sh
+case "$*" in
+*mergeable*) ;;
+*) echo "mergeable field was not requested" >&2; exit 2 ;;
+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"}}
+{"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"}
 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"}}]
+[{"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"}]
 JSON
 `,
 		)
@@ -220,11 +224,86 @@ pr: null
 				state: "merged",
 				draft: false,
 				merged: true,
+				mergeable: true,
 			},
 			claim: { state: "released", sessionId: "session-1" },
 		})
 	})
 
+	test("records a conflicting open PR without changing lifecycle status", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "example",
+							ticketUrl: null,
+							repo: "agency",
+							branch: "feat/example",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("example", undefined, 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(
+						"example",
+						undefined,
+						"https://github.com/example/agency/pull/42",
+						root,
+					),
+				),
+			),
+		)
+		await Bun.write(
+			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"}
+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.changes).toContainEqual(
+			expect.objectContaining({ kind: "record-pr", target: "task:example" }),
+		)
+		expect(applied.changes.some((change) => change.kind === "mark-done")).toBe(
+			false,
+		)
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("example", root)),
+			),
+		)
+		expect(task.data).toMatchObject({
+			status: "open",
+			pr: { state: "open", merged: false, mergeable: false },
+		})
+	})
+
 	test("queries and records a configured delivery provider", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/SyncService.ts

@@ -689,7 +689,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							"view",
 							existing.url,
 							"--json",
-							"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit",
+							"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
 						])
 						if (viewed.exitCode === 0) {
 							const detail = parseJson<Record<string, unknown>>(
@@ -729,7 +729,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								"--state",
 								"all",
 								"--json",
-								"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit",
+								"number,state,title,isDraft,headRefName,baseRefName,url,mergedAt,mergeCommit,mergeable",
 							],
 							{ cwd: repositoryPath },
 						)

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import {
 	parsePullRequestRecord,
+	recordFromGitHubJson,
 	resolveDeliveryCommand,
 	validateDelivery,
 } from "./delivery-command"
@@ -50,5 +51,37 @@ describe("delivery commands", () => {
 		expect(() =>
 			parsePullRequestRecord(JSON.stringify({ ...record, merged: false })),
 		).toThrow("inconsistent merge state")
+		expect(
+			parsePullRequestRecord(JSON.stringify({ ...record, mergeable: null })),
+		).toEqual({ ...record, mergeable: null })
+		expect(() =>
+			parsePullRequestRecord(JSON.stringify({ ...record, mergeable: "yes" })),
+		).toThrow("valid pull request record")
+	})
+
+	test("normalizes GitHub state and mergeability", () => {
+		const base = {
+			number: 17,
+			url: "https://github.com/example/agency/pull/17",
+			isDraft: false,
+		}
+		expect(
+			recordFromGitHubJson({ ...base, state: "OPEN", mergeable: "MERGEABLE" }),
+		).toMatchObject({ state: "open", merged: false, mergeable: true })
+		expect(
+			recordFromGitHubJson({
+				...base,
+				state: "OPEN",
+				mergeable: "CONFLICTING",
+			}),
+		).toMatchObject({ state: "open", merged: false, mergeable: false })
+		expect(
+			recordFromGitHubJson({
+				...base,
+				state: "CLOSED",
+				mergedAt: "2026-07-21T00:00:00Z",
+				mergeable: "UNKNOWN",
+			}),
+		).toMatchObject({ state: "merged", merged: true, mergeable: null })
 	})
 })

package/src/workbase/delivery-command.ts

@@ -119,13 +119,20 @@ 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 state = String(value.state ?? "OPEN").toLowerCase()
+	const githubState = String(value.state ?? "OPEN").toLowerCase()
+	const merged = githubState === "merged" || value.mergedAt != null
+	const mergeable = String(value.mergeable ?? "UNKNOWN").toLowerCase()
 	return {
 		...record,
-		state:
-			state === "merged" ? "merged" : state === "closed" ? "closed" : "open",
+		state: merged ? "merged" : githubState === "closed" ? "closed" : "open",
 		draft: value.isDraft === true,
-		merged: state === "merged" || value.mergedAt != null,
+		merged,
+		mergeable:
+			mergeable === "mergeable"
+				? true
+				: mergeable === "conflicting"
+					? false
+					: null,
 	} satisfies PullRequestRecord
 }
 

package/src/workbase/schemas.test.ts

@@ -185,11 +185,15 @@ describe("delivery configuration", () => {
 				state: "open",
 				draft: false,
 				merged: false,
+				mergeable: false,
 			},
 		})
 		expect(phase.pr && typeof phase.pr !== "string" && phase.pr.provider).toBe(
 			"forge",
 		)
+		expect(phase.pr && typeof phase.pr !== "string" && phase.pr.mergeable).toBe(
+			false,
+		)
 	})
 })
 

package/src/workbase/schemas.ts

@@ -72,6 +72,7 @@ export const PullRequestRecord = Schema.Struct({
 	state: Schema.Literal("open", "closed", "merged"),
 	draft: Schema.Boolean,
 	merged: Schema.Boolean,
+	mergeable: Schema.optional(Schema.NullOr(Schema.Boolean)),
 })
 
 const DeliveryProvider = Schema.Struct({