@markjaquith/agency 3.2.2 → 3.2.4

package/src/services/ReadinessService.test.ts

@@ -224,40 +224,6 @@ describe("ReadinessService", () => {
 			readiness.guardWorkTarget("execution-unit:phase/ship/implement", root),
 		)
 
-		await write(
-			root,
-			"tasks/ship/phases/implement/PHASE.md",
-			`---
-repo: agency
-branch: feat/implement
-base: main
-pr: null
-status: working
-claim:
-  claimant: orchestrator
-  agent: opencode
-  sessionId: session-1
-  startedAt: 2026-07-20T00:00:00.000Z
-  targetRevision: ${"a".repeat(64)}
-  state: active
----
-
-# Execution
-`,
-		)
-		expect(
-			await service((readiness) => readiness.getWorkTargetIds(root)),
-		).not.toContain("execution-unit:phase/ship/implement")
-		await expect(
-			service((readiness) =>
-				readiness.guardWorkTarget(
-					"execution-unit:phase/ship/implement",
-					root,
-					true,
-				),
-			),
-		).rejects.toThrow("active claim")
-
 		const blocked = await service((readiness) =>
 			Effect.either(readiness.guardWorkTarget("phase:ship/verify", root)),
 		)

package/src/services/ReadinessService.ts

@@ -46,22 +46,13 @@ const executionNodeId = (taskId: string, phaseId?: string) =>
 		? `execution-unit:phase/${taskId}/${phaseId}`
 		: `execution-unit:task/${taskId}`
 
-const hasActiveClaim = (node: GraphNode) =>
-	node.kind !== "epic" &&
-	node.kind !== "repository" &&
-	"claim" in node.data &&
-	node.data.claim?.state === "active"
-
 const isResumableWork = (node: GraphNode) =>
 	node.kind !== "repository" &&
 	node.status === "working" &&
-	!hasActiveClaim(node) &&
 	node.readiness.blockers.every((blocker) => blocker.kind !== "validation")
 
 const isWorkTarget = (node: GraphNode) =>
-	node.kind !== "repository" &&
-	!hasActiveClaim(node) &&
-	(node.readiness.ready || isResumableWork(node))
+	node.kind !== "repository" && (node.readiness.ready || isResumableWork(node))
 
 const itemFor = (
 	node: ExecutionNode,
@@ -200,16 +191,6 @@ export class ReadinessService extends Effect.Service<ReadinessService>()(
 							blockers: [],
 						})
 					}
-					if (hasActiveClaim(node)) {
-						return yield* new ExecutionGuardError({
-							message: `Cannot work on '${node.key}': it has an active claim. Use agency release or agency finish first.`,
-							action: "work",
-							target,
-							status: node.status!,
-							blockedBy: node.readiness!.blockedBy,
-							blockers: node.readiness!.blockers,
-						})
-					}
 					if (override) return
 					if (!node.readiness.ready && !isResumableWork(node)) {
 						const item = {

package/src/services/ReviewService.test.ts

@@ -11,7 +11,6 @@ import { GraphService } from "./GraphService"
 import { PullRequestService } from "./PullRequestService"
 import { PhaseService } from "./PhaseService"
 import { ArchiveService } from "./ArchiveService"
-import { ClaimService } from "./ClaimService"
 import { SyncService } from "./SyncService"
 import { task as taskCommand } from "../commands/task"
 
@@ -183,69 +182,6 @@ describe("ReviewService", () => {
 		).rejects.toThrow("cannot be converted to phases")
 	})
 
-	test("participates in claim lifecycle", async () => {
-		const task = await createReview()
-		const claimed = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "review",
-							claimant: "reviewer",
-							agent: "opencode",
-							sessionId: "session",
-							revision: task.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		expect(claimed.data.status).toBe("working")
-		const released = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.release(
-						{
-							taskId: "review",
-							sessionId: "session",
-							revision: claimed.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		expect(released.data.status).toBe("open")
-	})
-
-	test("rejects refresh while actively claimed", async () => {
-		const task = await createReview()
-		await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "review",
-							claimant: "reviewer",
-							agent: "opencode",
-							sessionId: "active",
-							revision: task.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		await expect(
-			runTestEffect(
-				ReviewService.pipe(
-					Effect.flatMap((service) => service.refresh("review", root)),
-				),
-			),
-		).rejects.toThrow("active claim")
-	})
-
 	test("rolls back document and checkout when pin advancement fails", async () => {
 		const created = await createReview()
 		const workspace = await runTestEffect(

package/src/services/ReviewService.ts

@@ -302,11 +302,6 @@ export class ReviewService extends Effect.Service<ReviewService>()(
 								})
 							}
 							const previousReview = task.data.review
-							if (task.data.claim?.state === "active") {
-								return yield* new ReviewError({
-									message: `Review task '${taskId}' has an active claim; release or finish it before refreshing`,
-								})
-							}
 							if (ifRevision && task.revision !== ifRevision) {
 								return yield* new RevisionConflictError({
 									path: task.path,

package/src/services/SyncService.test.ts

@@ -3,7 +3,6 @@ import { Effect } from "effect"
 import { chmod, mkdir, rm } from "node:fs/promises"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { ClaimService } from "./ClaimService"
 import { PullRequestService } from "./PullRequestService"
 import { SyncService } from "./SyncService"
 import { TaskService } from "./TaskService"
@@ -143,30 +142,6 @@ pr: null
 			["remote", "set-url", "origin", "git@github.com:example/agency.git"],
 			join(root, "repos/agency"),
 		)
-		const inspected = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.inspect("example", undefined, root),
-				),
-			),
-		)
-		await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "example",
-							claimant: "orchestrator",
-							agent: "agent",
-							sessionId: "session-1",
-							revision: inspected.revision,
-							expiresAt: "2099-01-01T00:00:00.000Z",
-						},
-						root,
-					),
-				),
-			),
-		)
 		await Bun.write(
 			join(workspace.codePath, "reference", "LOCAL.md"),
 			"dirty\n",
@@ -176,21 +151,13 @@ pr: null
 		const before = await Bun.file(taskPath).text()
 		const observed = await runTestEffect(
 			SyncService.pipe(
-				Effect.flatMap((service) =>
-					service.reconcile({ cwd: root, now: new Date("2100-01-02") }),
-				),
+				Effect.flatMap((service) => service.reconcile({ cwd: root })),
 			),
 		)
 
 		expect(observed.mode).toBe("dry-run")
-		expect(observed.warnings).toContainEqual(
-			expect.objectContaining({
-				kind: "dirty-reference",
-				target: "task:example",
-			}),
-		)
+		expect(observed.warnings).toEqual([])
 		expect(observed.changes.map((change) => change.kind)).toEqual([
-			"release-stale-claim",
 			"record-pr",
 			"mark-done",
 		])
@@ -199,16 +166,11 @@ pr: null
 		const applied = await runTestEffect(
 			SyncService.pipe(
 				Effect.flatMap((service) =>
-					service.reconcile({
-						cwd: root,
-						apply: true,
-						now: new Date("2100-01-02"),
-					}),
+					service.reconcile({ cwd: root, apply: true }),
 				),
 			),
 		)
 		expect(applied.changes.map((change) => change.kind)).toEqual([
-			"release-stale-claim",
 			"record-pr",
 			"mark-done",
 		])
@@ -236,7 +198,6 @@ pr: null
 				baseBranch: "main",
 				mergeable: true,
 			},
-			claim: { state: "released", sessionId: "session-1" },
 		})
 	})
 
@@ -314,6 +275,70 @@ JSON
 		})
 	})
 
+	test("rejects a concurrent target change before recording a pull request", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "concurrent",
+							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 taskPath = join(root, "tasks/concurrent/TASK.md")
+		await Bun.write(
+			join(root, "bin", "gh"),
+			`#!/bin/sh
+printf '\nConcurrent edit.\n' >> ${JSON.stringify(taskPath)}
+cat <<'JSON'
+[{"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
+`,
+		)
+		await chmod(join(root, "bin", "gh"), 0o755)
+
+		const failure = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({ cwd: root, apply: true }),
+				),
+				Effect.flip,
+			),
+		)
+		expect(failure).toMatchObject({
+			_tag: "RevisionConflictError",
+			message: expect.stringContaining("Revision conflict"),
+		})
+		const content = await Bun.file(taskPath).text()
+		expect(content).toContain("Concurrent edit.")
+		expect(content).not.toContain("provider: github")
+
+		await Bun.write(join(root, ".agency-graph-mutation.lock"), "busy")
+		const transactionFailure = await runTestEffect(
+			SyncService.pipe(
+				Effect.flatMap((service) =>
+					service.reconcile({ cwd: root, apply: true }),
+				),
+				Effect.flip,
+			),
+		)
+		expect(transactionFailure).toMatchObject({
+			_tag: "SyncError",
+			message: expect.stringContaining("graph mutation is in progress"),
+		})
+	})
+
 	test("queries and records a configured delivery provider", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -400,13 +425,13 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 		expect("pr" in task.data && task.data.pr).toEqual(record)
 	})
 
-	test("marks a successfully finished claim done only after merge", async () => {
+	test("marks working execution done after merge", async () => {
 		await runTestEffect(
 			TaskService.pipe(
 				Effect.flatMap((service) =>
 					service.create(
 						{
-							id: "finished-claim",
+							id: "working",
 							ticketUrl: null,
 							repo: "agency",
 							branch: "feat/example",
@@ -420,7 +445,7 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 		await runTestEffect(
 			WorktreeService.pipe(
 				Effect.flatMap((service) =>
-					service.materialize("finished-claim", undefined, root),
+					service.materialize("working", undefined, root),
 				),
 			),
 		)
@@ -428,48 +453,13 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 			["remote", "set-url", "origin", "git@github.com:example/agency.git"],
 			join(root, "repos/agency"),
 		)
-		const initial = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.inspect("finished-claim", undefined, root),
-				),
-			),
-		)
-		const claimed = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "finished-claim",
-							claimant: "orchestrator",
-							agent: "agent",
-							sessionId: "session-1",
-							revision: initial.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		const finished = await runTestEffect(
-			ClaimService.pipe(
+		await runTestEffect(
+			TaskService.pipe(
 				Effect.flatMap((service) =>
-					service.finish(
-						{
-							taskId: "finished-claim",
-							sessionId: "session-1",
-							revision: claimed.revision,
-							outcome: "done",
-						},
-						root,
-					),
+					service.setStatus("working", "working", root),
 				),
 			),
 		)
-		expect(finished.data).toMatchObject({
-			status: "working",
-			claim: { state: "finished", outcome: "done" },
-		})
 
 		const synced = await runTestEffect(
 			SyncService.pipe(
@@ -482,14 +472,11 @@ process.stdout.write(${JSON.stringify(JSON.stringify(record))})
 		expect(
 			await runTestEffect(
 				TaskService.pipe(
-					Effect.flatMap((service) => service.show("finished-claim", root)),
+					Effect.flatMap((service) => service.show("working", root)),
 				),
 			),
 		).toMatchObject({
-			data: {
-				status: "done",
-				claim: { state: "finished", outcome: "done" },
-			},
+			data: { status: "done" },
 		})
 	})