@markjaquith/agency 3.2.2 → 3.2.3

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" },
 		})
 	})
 

package/src/services/SyncService.ts

@@ -1,21 +1,28 @@
 import { Data, Effect, Either } from "effect"
 import { dirname, join, resolve } from "node:path"
 import type {
-	ClaimRecord,
 	PhaseFrontmatter,
 	RepositoryReference,
 	TaskFrontmatter,
 	WorkStatus,
 	PullRequestRecord,
 } from "../workbase/schemas"
+import { documentRevision } from "../workbase/document-revision"
+import {
+	formatMarkdownDocument,
+	parseFrontmatterSync,
+} from "../workbase/frontmatter"
 import {
 	normalizePullRequestRecord,
 	parseOptionalPullRequestRecord,
 	recordFromGitHubJson,
 	resolveDeliveryCommand,
 } from "../workbase/delivery-command"
-import { ClaimService } from "./ClaimService"
 import { FileSystemService } from "./FileSystemService"
+import {
+	documentWriteStep,
+	runLifecycleTransaction,
+} from "./LifecycleTransaction"
 import { WorkbaseService } from "./WorkbaseService"
 import { WorktreeService } from "./WorktreeService"
 import {
@@ -37,6 +44,7 @@ interface ExecutionRecord {
 	readonly taskId: string
 	readonly phaseId?: string
 	readonly path: string
+	readonly content: string
 	readonly revision: string
 	readonly data: ExecutionData
 }
@@ -49,11 +57,7 @@ interface RegisteredWorktree {
 }
 
 interface SyncChange {
-	readonly kind:
-		| "materialize-workspace"
-		| "release-stale-claim"
-		| "record-pr"
-		| "mark-done"
+	readonly kind: "materialize-workspace" | "record-pr" | "mark-done"
 	readonly target: string
 	readonly message: string
 	readonly status: "planned" | "applied"
@@ -84,7 +88,6 @@ interface ExecutionSyncState {
 	readonly status: WorkStatus
 	readonly branch: string | null
 	readonly base: string | null
-	readonly claim: ClaimRecord | null
 	readonly checkouts: readonly CheckoutState[]
 	readonly pr: Record<string, unknown>
 	readonly review?: {
@@ -140,11 +143,6 @@ const parseJson = <T>(value: string, fallback: T): T => {
 	}
 }
 
-const isExpired = (claim: ClaimRecord | undefined, now: Date) =>
-	claim?.state === "active" &&
-	claim.expiresAt !== undefined &&
-	Date.parse(claim.expiresAt) <= now.getTime()
-
 const isCommitId = (ref: string) => /^[0-9a-f]{40,64}$/i.test(ref)
 
 const originRef = (ref: string) =>
@@ -199,13 +197,32 @@ const mergedPullRequestFromGitHub = (
 	return current
 }
 
+const mutateExecution = (
+	root: string,
+	record: ExecutionRecord,
+	revision: string,
+	data: ExecutionData,
+) => {
+	const parsed = parseFrontmatterSync(record.content, record.path)
+	const content = formatMarkdownDocument(data, parsed.body)
+	return runLifecycleTransaction({
+		root,
+		preconditions: [{ path: record.path, revision }],
+		steps: [documentWriteStep(root, [{ path: record.path, content }])],
+	}).pipe(
+		Effect.as({ data, revision: documentRevision(content) }),
+		Effect.catchTag("LifecycleTransactionError", (error) =>
+			Effect.fail(new SyncError({ message: error.message })),
+		),
+	)
+}
+
 export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 	sync: () => ({
 		reconcile: (
 			options: {
 				readonly cwd?: string
 				readonly apply?: boolean
-				readonly now?: Date
 				readonly onProgress?: (progress: SyncProgress) => void
 				readonly taskId?: string
 				readonly phaseId?: string
@@ -215,7 +232,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				const fs = yield* FileSystemService
 				const workbase = yield* WorkbaseService
 				const worktrees = yield* WorktreeService
-				const claims = yield* ClaimService
 				const repositories = yield* RepositoryService
 				const versionControl = yield* VersionControlService
 				const { root, config } = yield* workbase.loadConfig(options.cwd)
@@ -255,6 +271,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 								taskId: task.id,
 								phaseId: phase.id,
 								path: phase.path,
+								content: phase.content,
 								revision: phase.revision,
 								data: phase.data,
 							})
@@ -264,6 +281,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 							key: `task:${task.id}`,
 							taskId: task.id,
 							path: task.path,
+							content: task.content,
 							revision: task.revision,
 							data: task.data,
 						})
@@ -299,7 +317,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 				})
 
 				const apply = options.apply === true
-				const now = options.now ?? new Date()
 				const changes: SyncChange[] = []
 				const warnings: SyncNotice[] = []
 				const unresolved: SyncNotice[] = []
@@ -500,8 +517,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						? null
 						: mergedPullRequestFromGitHub(data, query)
 					const skipCheckoutReconciliation =
-						Boolean(data.completion) ||
-						(remoteMergedPr !== null && data.claim?.state !== "active")
+						Boolean(data.completion) || remoteMergedPr !== null
 					let materialize = false
 					let workspaceConflict = false
 					const declared: readonly (
@@ -764,57 +780,12 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						})
 					}
 
-					if (
-						isExpired(data.claim, now) &&
-						(data.status === "working" || data.status === "delegated")
-					) {
-						const sessionId = data.claim!.sessionId
-						if (apply) {
-							const expired = yield* claims.expire(
-								{
-									taskId: record.taskId,
-									phaseId: record.phaseId,
-									revision,
-									now,
-								},
-								root,
-							)
-							data = expired.data as ExecutionData
-							revision = expired.revision
-						} else {
-							const claim: ClaimRecord = {
-								...data.claim!,
-								state: "released",
-								releasedAt: now.toISOString(),
-							}
-							data = { ...data, status: "open", claim }
-						}
-						changes.push({
-							kind: "release-stale-claim",
-							target: record.key,
-							message: `Release expired claim '${sessionId}'`,
-							status: apply ? "applied" : "planned",
-						})
-					} else if (
-						data.claim?.state === "active" &&
-						data.status !== "working" &&
-						data.status !== "delegated"
-					) {
-						unresolved.push({
-							kind: "claim-status-conflict",
-							target: record.key,
-							message: `Active claim conflicts with '${data.status}' status`,
-							action: "Release or finish the claim explicitly",
-						})
-					}
-
 					if (data.completion) {
 						executions.push({
 							target: record.key,
 							status: data.status,
 							branch: data.branch,
 							base: data.base,
-							claim: data.claim ?? null,
 							checkouts: checkoutStates,
 							pr: { url: null, state: "none" },
 						})
@@ -976,16 +947,11 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 
 					if (current && JSON.stringify(current) !== JSON.stringify(existing)) {
 						if (apply) {
-							const recorded = yield* claims.reconcile(
-								{
-									taskId: record.taskId,
-									phaseId: record.phaseId,
-									revision,
-									pr: current,
-								},
-								root,
-							)
-							data = recorded.data as ExecutionData
+							const recorded = yield* mutateExecution(root, record, revision, {
+								...data,
+								pr: current,
+							})
+							data = recorded.data
 							revision = recorded.revision
 						}
 						changes.push({
@@ -1002,35 +968,20 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						data.status !== "done" &&
 						data.status !== "dropped"
 					) {
-						if (data.claim?.state === "active") {
-							unresolved.push({
-								kind: "merged-with-active-claim",
-								target: record.key,
-								message:
-									"Pull request is merged while the execution unit remains claimed",
-								action: "Finish or release the active claim",
-							})
-						} else {
-							if (apply) {
-								const completed = yield* claims.reconcile(
-									{
-										taskId: record.taskId,
-										phaseId: record.phaseId,
-										revision,
-										status: "done",
-									},
-									root,
-								)
-								data = completed.data as ExecutionData
-								revision = completed.revision
-							}
-							changes.push({
-								kind: "mark-done",
-								target: record.key,
-								message: "Mark execution unit done from merged pull request",
-								status: apply ? "applied" : "planned",
+						if (apply) {
+							const completed = yield* mutateExecution(root, record, revision, {
+								...data,
+								status: "done",
 							})
+							data = completed.data
+							revision = completed.revision
 						}
+						changes.push({
+							kind: "mark-done",
+							target: record.key,
+							message: "Mark execution unit done from merged pull request",
+							status: apply ? "applied" : "planned",
+						})
 					}
 
 					executions.push({
@@ -1038,7 +989,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						status: data.status,
 						branch: data.branch,
 						base: data.base,
-						claim: data.claim ?? null,
 						checkouts: checkoutStates,
 						pr,
 					})
@@ -1047,27 +997,7 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 
 				for (const task of reviewRecords) {
 					if (!("review" in task.data)) continue
-					let data = task.data
-					let revision = task.revision
-					if (
-						isExpired(data.claim, now) &&
-						(data.status === "working" || data.status === "delegated")
-					) {
-						if (apply) {
-							const expired = yield* claims.expire(
-								{ taskId: task.id, revision, now },
-								root,
-							)
-							if ("review" in expired.data) data = expired.data
-							revision = expired.revision
-						}
-						changes.push({
-							kind: "release-stale-claim",
-							target: `task:${task.id}`,
-							message: `Release expired claim '${data.claim?.sessionId ?? "unknown"}'`,
-							status: apply ? "applied" : "planned",
-						})
-					}
+					const data = task.data
 					const inspection = yield* worktrees.inspect(task.id, undefined, root)
 					for (const conflict of inspection.conflicts) {
 						unresolved.push({
@@ -1118,7 +1048,6 @@ export class SyncService extends Effect.Service<SyncService>()("SyncService", {
 						status: data.status,
 						branch: null,
 						base: null,
-						claim: data.claim ?? null,
 						checkouts: checkout
 							? [
 									{

package/src/services/TaskPhaseService.test.ts

@@ -615,7 +615,19 @@ describe("task and phase services", () => {
 					),
 				),
 			),
-		).rejects.toThrow("Delegation requires explicit ownership")
+		).rejects.toThrow("Delegated status cannot be set directly")
+		await Bun.write(
+			createdTask.path,
+			workingTask.content.replace("status: working", "status: delegated"),
+		)
+		const reopenedDelegatedTask = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("single-status", "open", root),
+				),
+			),
+		)
+		expect(reopenedDelegatedTask.data.status).toBe("open")
 		await expect(
 			runTestEffect(
 				TaskService.pipe(

package/src/services/TaskService.ts

@@ -610,8 +610,7 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 				const validStatus = yield* decodeStatus(status)
 				if (validStatus === "delegated") {
 					return yield* new TaskError({
-						message:
-							"Delegation requires explicit ownership; use 'agency claim'",
+						message: "Delegated status cannot be set directly",
 					})
 				}
 				const record = yield* service.show(id, startPath)
@@ -620,11 +619,6 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						message: `Task '${id}' has multiple phases; set status on a phase instead`,
 					})
 				}
-				if (record.data.claim?.state === "active") {
-					return yield* new TaskError({
-						message: `Task '${id}' has an active claim; use agency release or agency finish`,
-					})
-				}
 				if (nonPrCompletion && validStatus !== "done") {
 					return yield* new TaskError({
 						message: "Non-PR completion is valid only with a done status",

package/src/services/WorkbaseService.ts

@@ -870,9 +870,6 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								"Non-PR completion cannot have a recorded pull request",
 							)
 						}
-						if (record.data.claim?.state === "active") {
-							issue(record.path, "Completed work cannot have an active claim")
-						}
 					}
 
 					for (const epic of epics.values()) {