@markjaquith/agency 3.2.1 → 3.2.3

package/src/workbase/schemas.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { Schema } from "@effect/schema"
 import {
 	EntityId,
-	ClaimRecord,
 	EpicFrontmatter,
 	PhaseFrontmatter,
 	TaskFrontmatter,
@@ -401,30 +400,18 @@ describe("work status", () => {
 	})
 })
 
-describe("claim records", () => {
-	const record = {
-		claimant: "orchestrator",
-		agent: "agent",
-		sessionId: "job-1",
-		startedAt: "2026-07-17T12:00:00.000Z",
-		targetRevision: "0".repeat(64),
-		expiresAt: "2026-07-17T13:00:00.000Z",
-		state: "active" as const,
-	}
-
-	test("accepts explicit ownership and revision metadata", () => {
-		expect(Schema.decodeUnknownSync(ClaimRecord)(record)).toEqual(record)
-	})
-
-	test("rejects malformed timestamps, revisions, and empty identities", () => {
-		for (const invalid of [
-			{ ...record, claimant: "" },
-			{ ...record, startedAt: "today" },
-			{ ...record, targetRevision: "abc" },
-		]) {
-			expect(() => Schema.decodeUnknownSync(ClaimRecord)(invalid)).toThrow()
-		}
-	})
+test("rejects removed claim frontmatter", () => {
+	expect(() =>
+		Schema.decodeUnknownSync(TaskFrontmatter, { onExcessProperty: "error" })({
+			ticketUrl: null,
+			repo: "agency",
+			branch: "task/example",
+			base: "main",
+			pr: null,
+			status: "working",
+			claim: { state: "active" },
+		}),
+	).toThrow()
 })
 
 describe("workbase registry", () => {

package/src/workbase/schemas.ts

@@ -50,19 +50,6 @@ export const DocumentRevision = Schema.String.pipe(
 	Schema.pattern(/^[a-f0-9]{64}$/),
 )
 
-export const ClaimRecord = Schema.Struct({
-	claimant: NonEmptyString,
-	agent: NonEmptyString,
-	sessionId: NonEmptyString,
-	startedAt: IsoTimestamp,
-	targetRevision: DocumentRevision,
-	expiresAt: Schema.optional(IsoTimestamp),
-	state: Schema.Literal("active", "released", "finished"),
-	releasedAt: Schema.optional(IsoTimestamp),
-	finishedAt: Schema.optional(IsoTimestamp),
-	outcome: Schema.optional(Schema.Literal("done", "dropped")),
-})
-
 const Url = NonEmptyString.pipe(Schema.pattern(/^[a-zA-Z][a-zA-Z0-9+.-]*:/))
 
 const GitHubPullRequestUrl = NonEmptyString.pipe(
@@ -163,7 +150,6 @@ const ExecutionUnit = {
 	base: NonEmptyString,
 	pr: Schema.NullOr(Schema.Union(GitHubPullRequestUrl, PullRequestRecord)),
 	status: Schema.optionalWith(WorkStatus, { default: () => "open" as const }),
-	claim: Schema.optional(ClaimRecord),
 	completion: Schema.optional(CompletionRecord),
 }
 
@@ -262,7 +248,6 @@ const ReviewTaskFrontmatter = Schema.Struct({
 	...TaskMetadata,
 	review: ReviewRecord,
 	status: Schema.optionalWith(WorkStatus, { default: () => "open" as const }),
-	claim: Schema.optional(ClaimRecord),
 	completion: Schema.optional(CompletionRecord),
 })
 
@@ -288,7 +273,6 @@ export type RepositoryDeclaration = Schema.Schema.Type<
 	typeof RepositoryDeclaration
 >
 export type WorkStatus = Schema.Schema.Type<typeof WorkStatus>
-export type ClaimRecord = Schema.Schema.Type<typeof ClaimRecord>
 export type PullRequestRecord = Schema.Schema.Type<typeof PullRequestRecord>
 export type ReviewSource = Schema.Schema.Type<typeof ReviewSource>
 export type ReviewRecord = Schema.Schema.Type<typeof ReviewRecord>

package/src/commands/claim.ts

@@ -1,122 +0,0 @@
-import { Effect } from "effect"
-import { ClaimService } from "../services/ClaimService"
-import type { BaseCommandOptions } from "../utils/command"
-import { createLoggers } from "../utils/effect"
-
-interface ClaimCommandOptions extends BaseCommandOptions {
-	readonly operation: "claim" | "release" | "finish"
-	readonly taskId?: string
-	readonly phaseId?: string
-	readonly claimant?: string
-	readonly agent?: string
-	readonly sessionId?: string
-	readonly revision?: string
-	readonly expiresAt?: string
-	readonly outcome?: string
-	readonly noPullRequest?: boolean
-	readonly summary?: string
-	readonly evidenceUrl?: string
-	readonly json?: boolean
-}
-
-export const claimCommand = (options: ClaimCommandOptions) =>
-	Effect.gen(function* () {
-		const claims = yield* ClaimService
-		const { log } = createLoggers(options)
-		const cwd = options.cwd ?? process.cwd()
-		if (!options.taskId || !options.sessionId || !options.revision) {
-			return yield* Effect.fail(new Error("Missing required claim arguments"))
-		}
-		if (
-			options.operation === "claim" &&
-			(!options.claimant || !options.agent)
-		) {
-			return yield* Effect.fail(
-				new Error("Claimant and agent identities are required"),
-			)
-		}
-		if (options.noPullRequest && !options.summary?.trim()) {
-			return yield* Effect.fail(
-				new Error("Non-PR completion requires a non-empty summary"),
-			)
-		}
-		if (options.noPullRequest && options.outcome !== "done") {
-			return yield* Effect.fail(
-				new Error("Non-PR completion is valid only with a done outcome"),
-			)
-		}
-		if (
-			options.operation === "finish" &&
-			options.outcome !== "done" &&
-			options.outcome !== "dropped"
-		) {
-			return yield* Effect.fail(
-				new Error("Finish outcome must be done or dropped"),
-			)
-		}
-
-		const common = {
-			taskId: options.taskId,
-			...(options.phaseId ? { phaseId: options.phaseId } : {}),
-			sessionId: options.sessionId,
-			revision: options.revision,
-		}
-		const result =
-			options.operation === "claim"
-				? yield* claims.claim(
-						{
-							...common,
-							claimant: options.claimant!,
-							agent: options.agent!,
-							...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
-						},
-						cwd,
-					)
-				: options.operation === "release"
-					? yield* claims.release(common, cwd)
-					: yield* claims.finish(
-							{
-								...common,
-								outcome: options.outcome as "done" | "dropped",
-								...(options.noPullRequest
-									? {
-											nonPrCompletion: {
-												summary: options.summary!,
-												...(options.evidenceUrl
-													? { evidenceUrl: options.evidenceUrl }
-													: {}),
-											},
-										}
-									: {}),
-							},
-							cwd,
-						)
-
-		const { data: _, ...output } = result
-		log(
-			options.json
-				? JSON.stringify(output, null, 2)
-				: `${options.operation === "claim" ? "Claimed" : options.operation === "release" ? "Released" : "Finished"} ${result.target} at revision ${result.revision}`,
-		)
-	})
-
-export const claimHelp = `
-Usage: agency claim <task-id> [phase-id] --claimant <id> --agent <id> --session-id <id> --revision <sha256>
-
-Claim an execution unit. Use distinct claimant and agent identities for delegated
-work. --expires-at accepts an optional future ISO-8601 timestamp.
-`
-
-export const releaseHelp = `
-Usage: agency release <task-id> [phase-id] --session-id <id> --revision <sha256>
-
-Release an execution unit owned by the session.
-`
-
-export const finishHelp = `
-Usage: agency finish <task-id> [phase-id] --session-id <id> --revision <sha256> --outcome <done|dropped> [--no-pull-request --summary <text> [--evidence-url <url>]]
-
-Finish a claim owned by the session. A done claim outcome leaves unmerged work
-working; agency sync marks the execution unit done after merge. Use
---no-pull-request with a summary for an explicit non-PR completion.
-`

package/src/services/ClaimService.test.ts

@@ -1,415 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { join } from "node:path"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { ClaimService } from "./ClaimService"
-import { PhaseService } from "./PhaseService"
-import { TaskService } from "./TaskService"
-
-const at = (value: string) => new Date(value)
-
-describe("claim service", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							id: "single",
-							ticketUrl: null,
-							repo: "agency",
-							branch: "task/single",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	const inspect = (taskId = "single", phaseId?: string) =>
-		runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) => service.inspect(taskId, phaseId, root)),
-			),
-		)
-
-	const claim = async (
-		revision: string,
-		sessionId = "session-1",
-		now = at("2026-07-17T12:00:00.000Z"),
-		expiresAt?: string,
-	) =>
-		runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "single",
-							claimant: "orchestrator-1",
-							agent: "agent-1",
-							sessionId,
-							revision,
-							now,
-							...(expiresAt ? { expiresAt } : {}),
-						},
-						root,
-					),
-				),
-			),
-		)
-
-	test("records ownership and guarded release and finish transitions", async () => {
-		const initial = await inspect()
-		const acquired = await claim(
-			initial.revision,
-			"session-1",
-			at("2026-07-17T12:00:00.000Z"),
-			"2026-07-17T13:00:00.000Z",
-		)
-
-		expect(acquired.claim).toEqual({
-			claimant: "orchestrator-1",
-			agent: "agent-1",
-			sessionId: "session-1",
-			startedAt: "2026-07-17T12:00:00.000Z",
-			targetRevision: initial.revision,
-			expiresAt: "2026-07-17T13:00:00.000Z",
-			state: "active",
-		})
-		expect((await inspect()).data.status).toBe("working")
-		await expect(
-			runTestEffect(
-				TaskService.pipe(
-					Effect.flatMap((service) =>
-						service.setStatus("single", "done", root),
-					),
-				),
-			),
-		).rejects.toThrow("has an active claim")
-
-		const released = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.release(
-						{
-							taskId: "single",
-							sessionId: "session-1",
-							revision: acquired.revision,
-							now: at("2026-07-17T12:15:00.000Z"),
-						},
-						root,
-					),
-				),
-			),
-		)
-		expect(released.data.status).toBe("open")
-		expect(released.claim).toMatchObject({
-			state: "released",
-			releasedAt: "2026-07-17T12:15:00.000Z",
-		})
-
-		const reacquired = await claim(
-			released.revision,
-			"session-2",
-			at("2026-07-17T12:20:00.000Z"),
-		)
-		const finished = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.finish(
-						{
-							taskId: "single",
-							sessionId: "session-2",
-							revision: reacquired.revision,
-							outcome: "done",
-							now: at("2026-07-17T12:45:00.000Z"),
-						},
-						root,
-					),
-				),
-			),
-		)
-		expect(finished.data.status).toBe("working")
-		expect(finished.claim).toMatchObject({
-			state: "finished",
-			finishedAt: "2026-07-17T12:45:00.000Z",
-			outcome: "done",
-		})
-	})
-
-	test("finishes claimed non-PR work with durable completion evidence", async () => {
-		const initial = await inspect()
-		const acquired = await claim(initial.revision)
-		const finished = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.finish(
-						{
-							taskId: "single",
-							sessionId: "session-1",
-							revision: acquired.revision,
-							outcome: "done",
-							nonPrCompletion: {
-								summary: "Review completed; no code change was needed.",
-								evidenceUrl: "https://example.com/review",
-							},
-							now: at("2026-07-17T12:45:00.000Z"),
-						},
-						root,
-					),
-				),
-			),
-		)
-
-		expect(finished.data).toMatchObject({
-			status: "done",
-			claim: { state: "finished", outcome: "done" },
-			completion: {
-				mode: "non-pr",
-				completedAt: "2026-07-17T12:45:00.000Z",
-				summary: "Review completed; no code change was needed.",
-				evidenceUrl: "https://example.com/review",
-			},
-		})
-	})
-
-	test("rejects invalid claimed non-PR completion", async () => {
-		const initial = await inspect()
-		const acquired = await claim(initial.revision)
-		await expect(
-			runTestEffect(
-				ClaimService.pipe(
-					Effect.flatMap((service) =>
-						service.finish(
-							{
-								taskId: "single",
-								sessionId: "session-1",
-								revision: acquired.revision,
-								outcome: "done",
-								nonPrCompletion: { summary: " " },
-							},
-							root,
-						),
-					),
-				),
-			),
-		).rejects.toThrow("summary must not be empty")
-	})
-
-	test("returns structured ownership and revision conflicts", async () => {
-		const initial = await inspect()
-		const acquired = await claim(initial.revision)
-
-		await expect(claim(acquired.revision, "session-2")).rejects.toThrow(
-			"is claimed by 'agent-1'",
-		)
-		await expect(
-			runTestEffect(
-				ClaimService.pipe(
-					Effect.flatMap((service) =>
-						service.release(
-							{
-								taskId: "single",
-								sessionId: "session-2",
-								revision: acquired.revision,
-							},
-							root,
-						),
-					),
-				),
-			),
-		).rejects.toThrow("does not own")
-		await expect(claim(initial.revision, "session-3")).rejects.toThrow(
-			"Revision conflict",
-		)
-	})
-
-	test("inspects a task without parsing unrelated task documents", async () => {
-		await mkdir(join(root, "tasks/broken"), { recursive: true })
-		await Bun.write(join(root, "tasks/broken/TASK.md"), "not frontmatter\n")
-
-		const inspected = await inspect()
-		expect(inspected.target.path).toBe(join(root, "tasks/single/TASK.md"))
-		expect(inspected.data).toMatchObject({ branch: "task/single" })
-	})
-
-	test("inspects a phase without parsing unrelated phase documents", async () => {
-		await mkdir(join(root, "tasks/phased/phases/target"), { recursive: true })
-		await mkdir(join(root, "tasks/phased/phases/broken"), { recursive: true })
-		await Bun.write(
-			join(root, "tasks/phased/TASK.md"),
-			"---\nticketUrl: null\nphases:\n  - id: target\n  - id: broken\nstatus: working\n---\n",
-		)
-		await Bun.write(
-			join(root, "tasks/phased/phases/target/PHASE.md"),
-			"---\nrepo: agency\nbranch: phase/target\nbase: main\npr: null\nstatus: open\n---\n",
-		)
-		await Bun.write(
-			join(root, "tasks/phased/phases/broken/PHASE.md"),
-			"not frontmatter\n",
-		)
-
-		const inspected = await inspect("phased", "target")
-		expect(inspected.target.path).toBe(
-			join(root, "tasks/phased/phases/target/PHASE.md"),
-		)
-		expect(inspected.data).toMatchObject({ branch: "phase/target" })
-	})
-	test("serializes concurrent claims and allows expired ownership replacement", async () => {
-		const initial = await inspect()
-		const attempts = await Promise.allSettled([
-			claim(initial.revision, "session-a"),
-			claim(initial.revision, "session-b"),
-		])
-		expect(
-			attempts.filter((result) => result.status === "fulfilled"),
-		).toHaveLength(1)
-		expect(
-			attempts.filter((result) => result.status === "rejected"),
-		).toHaveLength(1)
-		const current = await inspect()
-		expect(current.data.claim?.state).toBe("active")
-
-		await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.release(
-						{
-							taskId: "single",
-							sessionId: current.data.claim!.sessionId,
-							revision: current.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		const released = await inspect()
-		const expiring = await claim(
-			released.revision,
-			"expiring",
-			at("2026-07-17T12:00:00.000Z"),
-			"2026-07-17T12:01:00.000Z",
-		)
-		const replacement = await claim(
-			expiring.revision,
-			"replacement",
-			at("2026-07-17T12:02:00.000Z"),
-		)
-		expect(replacement.claim.sessionId).toBe("replacement")
-	})
-
-	test("claims phases and rejects multi-phase task containers", async () => {
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{ id: "multi", ticketUrl: null, multiPhase: true },
-						root,
-					),
-				),
-			),
-		)
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							taskId: "multi",
-							id: "implementation",
-							repo: "agency",
-							branch: "task/multi",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		await expect(inspect("multi")).rejects.toThrow("claim a phase instead")
-		const phase = await inspect("multi", "implementation")
-		const acquired = await runTestEffect(
-			ClaimService.pipe(
-				Effect.flatMap((service) =>
-					service.claim(
-						{
-							taskId: "multi",
-							phaseId: "implementation",
-							claimant: "orchestrator",
-							agent: "agent",
-							sessionId: "phase-session",
-							revision: phase.revision,
-						},
-						root,
-					),
-				),
-			),
-		)
-		expect(acquired.target).toBe("phase 'multi/implementation'")
-	})
-
-	test("inspects only the requested task on large workbases", async () => {
-		for (let index = 0; index < 100; index += 1) {
-			const taskRoot = join(root, "tasks", `unrelated-${index}`)
-			await mkdir(taskRoot, { recursive: true })
-			await writeFile(join(taskRoot, "TASK.md"), "not valid frontmatter\n")
-		}
-
-		const inspected = await inspect()
-		expect(inspected.target.path).toBe(join(root, "tasks/single/TASK.md"))
-		expect(inspected.data.status).toBe("open")
-	})
-
-	test("inspects only the requested phase", async () => {
-		await runTestEffect(
-			TaskService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{ id: "multi", ticketUrl: null, multiPhase: true },
-						root,
-					),
-				),
-			),
-		)
-		await runTestEffect(
-			PhaseService.pipe(
-				Effect.flatMap((service) =>
-					service.create(
-						{
-							taskId: "multi",
-							id: "requested",
-							repo: "agency",
-							branch: "task/multi",
-							base: "main",
-						},
-						root,
-					),
-				),
-			),
-		)
-		const taskPath = join(root, "tasks/multi/TASK.md")
-		await writeFile(
-			taskPath,
-			(await readFile(taskPath, "utf8")).replace("multi", "["),
-		)
-		const unrelatedPhase = join(root, "tasks/multi/phases/unrelated")
-		await mkdir(unrelatedPhase, { recursive: true })
-		await writeFile(join(unrelatedPhase, "PHASE.md"), "not valid frontmatter\n")
-
-		const inspected = await inspect("multi", "requested")
-		expect(inspected.target.path).toBe(
-			join(root, "tasks/multi/phases/requested/PHASE.md"),
-		)
-		expect(inspected.data.status).toBe("open")
-	})
-})