@markjaquith/agency 2.71.6 → 2.71.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.6",
+  "version": "2.71.8",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -68,8 +68,10 @@
     "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",
+    "benchmark:worktree": "bun scripts/benchmark-worktree.ts",
     "test": "find src \\( -name '*.test.ts' -o -name '*.test.tsx' \\) -print0 | xargs -0 -n 1 -P 4 bun test",
     "test:opencode": "AGENCY_TEST_OPENCODE=1 bun test src/cli.test.ts --test-name-pattern 'provides effective whole-workbase OpenCode access'",
     "format": "oxfmt",

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

package/src/services/PhaseService.ts

@@ -105,7 +105,8 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							message: `Review task '${taskId}' cannot be converted to phases`,
 						})
 					}
-					const isMultiPhase = "phases" in task.data
+					const taskData = task.data
+					const isMultiPhase = "phases" in taskData
 					let firstPhaseId: string | undefined
 					if (!isMultiPhase) {
 						if (!input.firstPhase) {
@@ -129,7 +130,7 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 
 					if (
 						isMultiPhase &&
-						task.data.phases.some((phase) => phase.id === id)
+						taskData.phases.some((phase) => phase.id === id)
 					) {
 						return yield* new PhaseError({
 							message: `Phase '${id}' already exists on task '${taskId}'`,
@@ -142,7 +143,7 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					}
 					const knownPhases = new Set(
 						isMultiPhase
-							? task.data.phases.map((phase) => phase.id)
+							? taskData.phases.map((phase) => phase.id)
 							: [firstPhaseId!],
 					)
 					for (const dependency of input.dependsOn ?? []) {
@@ -163,7 +164,7 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 						base: input.base,
 						pr: null,
 					})
-					const existingExecution = isMultiPhase ? undefined : task.data
+					const existingExecution = isMultiPhase ? undefined : taskData
 					const aliases = new Set([
 						data.repo,
 						...(data.repos ?? []).map((reference) => reference.repo),
@@ -226,15 +227,15 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							})
 						}
 						const firstData = yield* decodePhase({
-							repo: task.data.repo,
-							...(task.data.repos?.length ? { repos: task.data.repos } : {}),
-							branch: task.data.branch,
-							base: task.data.base,
-							pr: task.data.pr,
-							status: task.data.status,
-							...(task.data.claim ? { claim: task.data.claim } : {}),
-							...(task.data.completion
-								? { completion: task.data.completion }
+							repo: taskData.repo,
+							...(taskData.repos?.length ? { repos: taskData.repos } : {}),
+							branch: taskData.branch,
+							base: taskData.base,
+							pr: taskData.pr,
+							status: taskData.status,
+							...(taskData.claim ? { claim: taskData.claim } : {}),
+							...(taskData.completion
+								? { completion: taskData.completion }
 								: {}),
 						})
 						const firstTitle = firstPhaseId!
@@ -514,9 +515,9 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					}
 
 					const updatedTaskData = {
-						...task.data,
+						...taskData,
 						phases: [
-							...task.data.phases,
+							...taskData.phases,
 							{
 								id,
 								...(input.dependsOn?.length
@@ -552,14 +553,18 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					} satisfies PhaseRecord
 				}),
 
-			list: (taskId: string, startPath: string = process.cwd()) =>
+			list: (
+				taskId: string,
+				startPath: string = process.cwd(),
+				parentAlreadyLoaded = false,
+			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
 					const workbase = yield* WorkbaseService
 					const tasks = yield* TaskService
 					const root = yield* workbase.discover(startPath)
 					const validTaskId = yield* decodeId(taskId, "task")
-					yield* tasks.show(validTaskId, root)
+					if (!parentAlreadyLoaded) yield* tasks.show(validTaskId, root)
 					const directory = join(root, "tasks", validTaskId, "phases")
 					if (!(yield* fs.isDirectory(directory))) return [] as PhaseRecord[]
 					const entries = (yield* fs.readDirectory(directory))
@@ -586,17 +591,36 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 
 			show: (taskId: string, id: string, startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const service = yield* PhaseService
+					const fs = yield* FileSystemService
+					const workbase = yield* WorkbaseService
+					const tasks = yield* TaskService
+					const validTaskId = yield* decodeId(taskId, "task")
 					const validId = yield* decodeId(id, "phase")
-					const record = (yield* service.list(taskId, startPath)).find(
-						(phase) => phase.id === validId,
+					const root = yield* workbase.discover(startPath)
+					yield* tasks.show(validTaskId, root)
+					const path = join(
+						root,
+						"tasks",
+						validTaskId,
+						"phases",
+						validId,
+						"PHASE.md",
 					)
-					if (!record) {
+					if (!(yield* fs.exists(path))) {
 						return yield* new PhaseError({
-							message: `Phase '${validId}' does not exist on task '${taskId}'`,
+							message: `Phase '${validId}' does not exist on task '${validTaskId}'`,
 						})
 					}
-					return record
+					const content = yield* fs.readFile(path)
+					const parsed = yield* parseFrontmatter(content, path)
+					return {
+						taskId: validTaskId,
+						id: validId,
+						path,
+						content,
+						revision: documentRevision(content),
+						data: yield* decodePhase(parsed.data),
+					} satisfies PhaseRecord
 				}),
 
 			setStatus: (

package/src/services/TaskService.ts

@@ -582,17 +582,25 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 
 		show: (id: string, startPath: string = process.cwd()) =>
 			Effect.gen(function* () {
-				const service = yield* TaskService
+				const fs = yield* FileSystemService
+				const workbase = yield* WorkbaseService
 				const validId = yield* decodeId(id)
-				const record = (yield* service.list(startPath)).find(
-					(task) => task.id === validId,
-				)
-				if (!record) {
+				const root = yield* workbase.discover(startPath)
+				const path = join(root, "tasks", validId, "TASK.md")
+				if (!(yield* fs.exists(path))) {
 					return yield* new TaskError({
 						message: `Task '${validId}' does not exist`,
 					})
 				}
-				return record
+				const content = yield* fs.readFile(path)
+				const parsed = yield* parseFrontmatter(content, path)
+				return {
+					id: validId,
+					path,
+					content,
+					revision: documentRevision(content),
+					data: yield* decodeTask(parsed.data),
+				} satisfies TaskRecord
 			}),
 
 		setStatus: (

package/src/services/WorktreePerformance.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { PhaseService } from "./PhaseService"
+import { TaskService } from "./TaskService"
+
+const taskDocument = (id: string) => `---
+ticketUrl: null
+repo: agency
+branch: task/${id}
+base: main
+pr: null
+status: open
+---
+
+# ${id}
+`
+
+describe("worktree document loading", () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("shows a task without parsing sibling task documents", async () => {
+		await mkdir(join(root, "tasks/target"), { recursive: true })
+		await mkdir(join(root, "tasks/broken"), { recursive: true })
+		await Bun.write(join(root, "tasks/target/TASK.md"), taskDocument("target"))
+		await Bun.write(join(root, "tasks/broken/TASK.md"), "invalid frontmatter")
+
+		const task = await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) => service.show("target", root)),
+			),
+		)
+
+		expect(task.id).toBe("target")
+	})
+
+	test("lists phases from a preloaded task without rereading its parent", async () => {
+		const phasePath = join(root, "tasks/multi/phases/build")
+		await mkdir(phasePath, { recursive: true })
+		await Bun.write(
+			join(phasePath, "PHASE.md"),
+			`---
+repo: agency
+branch: task/multi-build
+base: main
+pr: null
+status: open
+---
+
+# Build
+`,
+		)
+
+		const phases = await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) => service.list("multi", root, true)),
+			),
+		)
+
+		expect(phases.map(({ id }) => id)).toEqual(["build"])
+	})
+})

package/src/services/WorktreeService.ts

@@ -1089,7 +1089,7 @@ const buildInspectionContext = (
 			if ("phases" in task.data) {
 				const phaseRecords =
 					preloadedPhasesByTask?.get(task.id) ??
-					(yield* phaseService.list(task.id, root))
+					(yield* phaseService.list(task.id, root, true))
 				phasesByTask.set(task.id, phaseRecords)
 				for (const phase of phaseRecords) {
 					addExecution(phase.data, {
@@ -3593,12 +3593,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 						})
 					}
 
-					const current = yield* inspectExecution(
-						taskId,
-						phaseId,
-						inspection.root,
-					)
-					if (current.checkouts.some((checkout) => !checkout.exists)) {
+					if (repaired.checkouts.some((checkout) => !checkout.exists)) {
 						const workspace = yield* service
 							.materialize(taskId, phaseId, inspection.root, {
 								...options,