@markjaquith/agency 2.71.7 → 2.71.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.7",
+  "version": "2.71.8",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -71,6 +71,7 @@
     "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/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,