@markjaquith/agency 2.71.6 → 2.71.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.6",
+  "version": "2.71.7",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -68,6 +68,7 @@
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
+    "benchmark:finish": "bun scripts/benchmark-finish.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",
     "test": "find src \\( -name '*.test.ts' -o -name '*.test.tsx' \\) -print0 | xargs -0 -n 1 -P 4 bun test",

package/src/services/ClaimService.test.ts

@@ -234,6 +234,38 @@ describe("claim service", () => {
 		)
 	})
 
+	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([

package/src/services/ClaimService.ts

@@ -10,10 +10,7 @@ import {
 	writeFile,
 } from "node:fs/promises"
 import { basename, dirname, join, relative } from "node:path"
-import { PhaseService } from "./PhaseService"
-import { TaskService } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
-import { FileSystemService } from "./FileSystemService"
 import {
 	documentRevision,
 	isDocumentRevision,
@@ -66,6 +63,47 @@ interface ClaimTarget {
 	readonly label: string
 }
 
+const resolveTarget = async (
+	root: string,
+	taskId: string,
+	phaseId?: string,
+): Promise<ClaimTarget> => {
+	const taskPath = join(root, "tasks", taskId, "TASK.md")
+	const path = phaseId
+		? join(root, "tasks", taskId, "phases", phaseId, "PHASE.md")
+		: taskPath
+	try {
+		await stat(taskPath)
+	} catch {
+		throw new ClaimError({ message: `Task '${taskId}' does not exist` })
+	}
+	if (phaseId) {
+		try {
+			await stat(path)
+		} catch {
+			throw new ClaimError({
+				message: `Phase '${phaseId}' does not exist on task '${taskId}'`,
+			})
+		}
+	}
+	return phaseId
+		? {
+				kind: "phase",
+				root,
+				taskId,
+				phaseId,
+				path,
+				label: `phase '${taskId}/${phaseId}'`,
+			}
+		: {
+				kind: "task",
+				root,
+				taskId,
+				path,
+				label: `task '${taskId}'`,
+			}
+}
+
 interface ClaimInput {
 	readonly taskId: string
 	readonly phaseId?: string
@@ -276,43 +314,24 @@ export class ClaimService extends Effect.Service<ClaimService>()(
 				startPath: string = process.cwd(),
 			) =>
 				Effect.gen(function* () {
-					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
-					const tasks = yield* TaskService
-					const phases = yield* PhaseService
 					const root = yield* workbase.discover(startPath)
-					const task = yield* tasks.show(taskId, root)
-					const phase = phaseId
-						? yield* phases.show(task.id, phaseId, root)
-						: undefined
-					const target: ClaimTarget = phaseId
-						? {
-								kind: "phase",
-								root,
-								taskId: task.id,
-								phaseId,
-								path: phase!.path,
-								label: `phase '${task.id}/${phaseId}'`,
-							}
-						: {
-								kind: "task",
-								root,
-								taskId: task.id,
-								path: task.path,
-								label: `task '${task.id}'`,
-							}
-					if (!phaseId && "phases" in task.data) {
+					const target = yield* operation(() =>
+						resolveTarget(root, taskId, phaseId),
+					)
+					const content = yield* operation(() => readFile(target.path, "utf8"))
+					const parsed = parseFrontmatterSync(content, target.path)
+					const data = decodeExecution(target, parsed.data)
+					if (!phaseId && "phases" in data) {
 						return yield* new ClaimError({
 							target: target.label,
-							message: `Task '${task.id}' has multiple phases; claim a phase instead`,
+							message: `Task '${taskId}' has multiple phases; claim a phase instead`,
 						})
 					}
-					const content = yield* fs.readFile(target.path)
-					const parsed = parseFrontmatterSync(content, target.path)
 					return {
 						target,
 						revision: documentRevision(content),
-						data: decodeExecution(target, parsed.data),
+						data,
 					}
 				}),