@markjaquith/agency 3.2.2 → 3.2.3

package/src/services/ArchiveBulkService.test.ts

@@ -335,94 +335,6 @@ describe("ArchiveService bulk task archive", () => {
 		).toBe(true)
 	})
 
-	test("skips task- and phase-level active claims", async () => {
-		await createTask("claimed")
-		await dropTask("claimed")
-		const taskPath = join(root, "tasks/claimed/TASK.md")
-		await Bun.write(
-			taskPath,
-			(await Bun.file(taskPath).text()).replace(
-				"status: dropped\n",
-				`status: dropped
-claim:
-  claimant: orchestrator
-  agent: opencode
-  sessionId: task-session
-  startedAt: 2026-08-07T00:00:00.000Z
-  targetRevision: ${"a".repeat(64)}
-  state: active
-`,
-			),
-		)
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{ id: "multi-claimed", ticketUrl: null, multiPhase: true },
-						root,
-					),
-				),
-			),
-		)
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							taskId: "multi-claimed",
-							id: "phase",
-							repo: "agency",
-							branch: "task/multi-claimed",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.setStatus("multi-claimed", "phase", "dropped", root),
-				),
-			),
-		)
-		const phasePath = join(root, "tasks/multi-claimed/phases/phase/PHASE.md")
-		await Bun.write(
-			phasePath,
-			(await Bun.file(phasePath).text()).replace(
-				"status: dropped\n",
-				`status: dropped
-claim:
-  claimant: orchestrator
-  agent: opencode
-  sessionId: phase-session
-  startedAt: 2026-08-07T00:00:00.000Z
-  targetRevision: ${"b".repeat(64)}
-  state: active
-`,
-			),
-		)
-
-		const result = await archiveTasks(true)
-
-		expect(result.tasks).toMatchObject([
-			{
-				id: "claimed",
-				disposition: "skipped",
-				reason: { code: "active-claim", details: ["task:claimed"] },
-			},
-			{
-				id: "multi-claimed",
-				disposition: "skipped",
-				reason: {
-					code: "active-claim",
-					details: ["phase:multi-claimed/phase"],
-				},
-			},
-		])
-	})
-
 	test("rolls back the entire cohort when application fails", async () => {
 		await runTestEffect(
 			EpicService.pipe(

package/src/services/ArchiveService.ts

@@ -111,7 +111,6 @@ interface LifecycleOptions {
 
 type TaskArchiveSkipCode =
 	| "non-terminal"
-	| "active-claim"
 	| "dirty-worktree"
 	| "checkout-preflight-failed"
 	| "retained-dependent"
@@ -169,7 +168,6 @@ interface TaskArchiveContext {
 	readonly executionUnits: readonly { taskId: string; phaseId?: string }[]
 	readonly terminal: boolean
 	readonly terminalDetails: readonly string[]
-	readonly activeClaims: readonly string[]
 }
 
 const loadTaskArchiveContext = (task: TaskRecord, root: string) =>
@@ -182,8 +180,6 @@ const loadTaskArchiveContext = (task: TaskRecord, root: string) =>
 				executionUnits: [{ taskId: task.id }],
 				terminal: isTerminalStatus(task.data.status),
 				terminalDetails: [`status=${task.data.status}`],
-				activeClaims:
-					task.data.claim?.state === "active" ? [`task:${task.id}`] : [],
 			} satisfies TaskArchiveContext
 		}
 
@@ -207,9 +203,6 @@ const loadTaskArchiveContext = (task: TaskRecord, root: string) =>
 					: phaseRecords.map(
 							(phase) => `phase:${phase.id}:status=${phase.data.status}`,
 						),
-			activeClaims: phaseRecords
-				.filter((phase) => phase.data.claim?.state === "active")
-				.map((phase) => `phase:${task.id}/${phase.id}`),
 		} satisfies TaskArchiveContext
 	})
 
@@ -217,9 +210,6 @@ const archiveEligibilityError = (context: TaskArchiveContext) => {
 	if (!context.terminal) {
 		return `Task '${context.task.id}' is not terminal (${context.terminalDetails.join(", ")}); only done or dropped tasks can be archived`
 	}
-	if (context.activeClaims.length > 0) {
-		return `Task '${context.task.id}' has active claims (${context.activeClaims.join(", ")}); release or finish them before archiving`
-	}
 	return undefined
 }
 
@@ -735,11 +725,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					const executionUnits: { taskId: string; phaseId?: string }[] = []
 					const phaseRecords: PhaseRecord[] = []
 					for (const task of taskRecords) {
-						if ("claim" in task.data && task.data.claim?.state === "active") {
-							return yield* new ArchiveError({
-								message: `Task '${task.id}' has an active claim; release or finish it before archiving`,
-							})
-						}
 						if ("phases" in task.data) {
 							for (const phase of task.data.phases) {
 								const record = yield* (yield* PhaseService).show(
@@ -747,11 +732,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 									phase.id,
 									root,
 								)
-								if (record.data.claim?.state === "active") {
-									return yield* new ArchiveError({
-										message: `Phase '${phase.id}' has an active claim; release or finish it before archiving`,
-									})
-								}
 								phaseRecords.push(record)
 								executionUnits.push({ taskId: task.id, phaseId: phase.id })
 							}
@@ -910,13 +890,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 							})
 							continue
 						}
-						if (context.activeClaims.length > 0) {
-							skipped.set(task.id, {
-								code: "active-claim",
-								details: context.activeClaims,
-							})
-							continue
-						}
 						const destination = archivedTaskDirectory(root, task.id)
 						if (yield* fs.exists(destination)) {
 							skipped.set(task.id, {
@@ -1398,11 +1371,6 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					const declaration = task.data.phases.find(
 						(candidate) => candidate.id === id,
 					)!
-					if (phase.data.claim?.state === "active") {
-						return yield* new ArchiveError({
-							message: `Phase '${id}' has an active claim; release or finish it before archiving`,
-						})
-					}
 					const dependent = task.data.phases.find((candidate) =>
 						candidate.dependsOn?.includes(id),
 					)

package/src/services/GraphMutationService.ts

@@ -376,15 +376,6 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 							message: `Task '${id}' has multiple phases; update execution metadata on a phase instead`,
 						})
 					}
-					if (
-						executionChange &&
-						"claim" in record.data &&
-						record.data.claim?.state === "active"
-					) {
-						return yield* new GraphMutationError({
-							message: `Task '${id}' has an active claim; release or finish it before changing execution metadata`,
-						})
-					}
 					if (
 						updates.pr &&
 						"completion" in record.data &&
@@ -526,11 +517,6 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 							message: `Phase '${id}' has materialized code; remove its worktree with Agency before changing execution metadata`,
 						})
 					}
-					if (executionChange && record.data.claim?.state === "active") {
-						return yield* new GraphMutationError({
-							message: `Phase '${id}' has an active claim; release or finish it before changing execution metadata`,
-						})
-					}
 					if (updates.pr && record.data.completion) {
 						return yield* new GraphMutationError({
 							message:
@@ -842,10 +828,6 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						return yield* new GraphMutationError({
 							message: `Task '${newId}' already exists`,
 						})
-					if ("claim" in task.data && task.data.claim?.state === "active")
-						return yield* new GraphMutationError({
-							message: `Task '${id}' has an active claim; release or finish it before renaming`,
-						})
 					if (yield* fs.isDirectory(join(from, "code")))
 						return yield* new GraphMutationError({
 							message: `Task '${id}' has a materialized worktree; remove it with Agency before renaming`,
@@ -859,10 +841,6 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 								root,
 							)
 							movedPhases.push(record)
-							if (record.data.claim?.state === "active")
-								return yield* new GraphMutationError({
-									message: `Phase '${phase.id}' has an active claim; release or finish it before renaming task '${id}'`,
-								})
 							if (yield* fs.isDirectory(join(dirname(record.path), "code")))
 								return yield* new GraphMutationError({
 									message: `Phase '${phase.id}' has a materialized worktree; remove it with Agency before renaming task '${id}'`,
@@ -952,10 +930,6 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 						})
 					}
 					const phase = yield* phases.show(taskId, id, root)
-					if (phase.data.claim?.state === "active")
-						return yield* new GraphMutationError({
-							message: `Phase '${id}' has an active claim; release or finish it before renaming`,
-						})
 					const from = dirname(phase.path)
 					const to = join(dirname(from), newId)
 					if (yield* fs.exists(to))

package/src/services/GraphService.test.ts

@@ -230,7 +230,7 @@ describe("GraphService", () => {
 		expect(calls).toBe(0)
 	})
 
-	test("never reports claimed or terminal execution units as ready", async () => {
+	test("never reports active or terminal execution units as ready", async () => {
 		const root = await createWorkbase()
 		roots.push(root)
 		const path = "tasks/ship/phases/implement/PHASE.md"

package/src/services/IntegrationService.test.ts

@@ -177,7 +177,7 @@ describe("IntegrationService", () => {
 			"agency task status <task> dropped --if-revision <revision> --json",
 			"Continue already materialized work",
 			"agency pr create <task> [phase]",
-			"agency finish <task> [phase] --session-id <id>",
+			"agency task status <task> done --if-revision <revision> --no-pull-request",
 			"agency task create <slug> --multi-phase",
 			"agency task handoff <investigation-task> <new-task>",
 			"agency review refresh <task> --if-revision <revision> --json",
@@ -626,7 +626,7 @@ describe("IntegrationService", () => {
 		)
 		expect(body).toContain("Never invent entity IDs")
 		expect(body).toContain("Preserve parent backlinks")
-		expect(body).toContain("dirty-worktree, active-claim, revision")
+		expect(body).toContain("dirty-worktree, revision")
 		expect(body).toContain("`agency work` is the human launch flow")
 		expect(body).toContain("Agency worker launch target: <target>.")
 		expect(body).toContain("environment variables and a generated")
@@ -636,7 +636,7 @@ describe("IntegrationService", () => {
 		)
 		expect(body).toMatch(/If\s+the prompt\s+and context disagree/)
 		expect(body).toContain("marks execution work")
-		expect(body).toContain("without creating a claim")
+		expect(body).toContain("marks execution work")
 		expect(body).toContain("formatting, type checks, build, dead-code checks")
 		expect(body).toContain("Review and commit the diff")
 		expect(body).toContain("Use `agency push`")
@@ -650,7 +650,7 @@ describe("IntegrationService", () => {
 		expect(body).toContain("marking it ready")
 		expect(body).toMatch(/completing\s+a refinement loop/)
 		expect(body).toContain("pausing or handing off")
-		expect(body).toContain("`agency finish`")
+		expect(body).toContain("update status")
 		expect(body).toContain("`agency sync`")
 		expect(body).toContain("`--no-pull-request --summary <text>`")
 		expect(body).toContain("`TASK.md` or `PHASE.md`")

package/src/services/LifecycleTransaction.ts

@@ -262,7 +262,11 @@ export const runLifecycleTransaction = ({
 					})
 				}
 			} catch (cause) {
-				if (cause instanceof LifecycleTransactionError) throw cause
+				if (
+					cause instanceof LifecycleTransactionError ||
+					cause instanceof RevisionConflictError
+				)
+					throw cause
 				const rollbackErrors: unknown[] = []
 				for (const step of [...completed].reverse()) {
 					if (!step.rollback) continue

package/src/services/PhaseService.ts

@@ -230,7 +230,6 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							base: taskData.base,
 							pr: taskData.pr,
 							status: taskData.status,
-							...(taskData.claim ? { claim: taskData.claim } : {}),
 							...(taskData.completion
 								? { completion: taskData.completion }
 								: {}),
@@ -515,16 +514,10 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					const validStatus = yield* decodeStatus(status)
 					if (validStatus === "delegated") {
 						return yield* new PhaseError({
-							message:
-								"Delegation requires explicit ownership; use 'agency claim'",
+							message: "Delegated status cannot be set directly",
 						})
 					}
 					const record = yield* service.show(taskId, id, startPath)
-					if (record.data.claim?.state === "active") {
-						return yield* new PhaseError({
-							message: `Phase '${id}' has an active claim; use agency release or agency finish`,
-						})
-					}
 					if (nonPrCompletion && validStatus !== "done") {
 						return yield* new PhaseError({
 							message: "Non-PR completion is valid only with a done status",

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,