@markjaquith/agency 2.71.5 → 2.71.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.5",
+  "version": "2.71.7",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -66,7 +66,9 @@
     "preuninstall": "bun scripts/install-pi-extension.ts uninstall",
     "benchmark:status": "bun scripts/benchmark-status.ts",
     "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/commands/doctor.test.ts

@@ -100,10 +100,6 @@ status: open
 					id: "ref.agency.main",
 					status: "pass",
 				}),
-				expect.objectContaining({
-					id: "worktree.task.example",
-					status: "pass",
-				}),
 			]),
 		)
 		for (const check of report.checks) {

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/DoctorService.ts

@@ -2,12 +2,11 @@ import { Effect, Either } from "effect"
 import { constants } from "node:fs"
 import { access } from "node:fs/promises"
 import { isAbsolute, join, resolve } from "node:path"
-import { EpicService } from "./EpicService"
 import { FileSystemService } from "./FileSystemService"
 import { IntegrationService } from "./IntegrationService"
-import { PhaseService } from "./PhaseService"
+import type { PhaseRecord } from "./PhaseService"
 import { RepositoryService } from "./RepositoryService"
-import { TaskService } from "./TaskService"
+import type { TaskRecord } from "./TaskService"
 import { WorkbaseService } from "./WorkbaseService"
 import { WorktreeService } from "./WorktreeService"
 import { VersionControlService } from "./VersionControlService"
@@ -80,12 +79,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 		sync: () => ({
 			inspect: (startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
-					const epics = yield* EpicService
 					const fs = yield* FileSystemService
 					const integrations = yield* IntegrationService
-					const phases = yield* PhaseService
 					const repositories = yield* RepositoryService
-					const tasks = yield* TaskService
 					const workbases = yield* WorkbaseService
 					const worktrees = yield* WorktreeService
 					const versionControl = yield* VersionControlService
@@ -105,49 +101,60 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 									: null,
 						})
 
-					const tool = function* (
+					const tool = (
 						id: string,
 						executable: string,
 						level: DoctorCheckLevel,
 						label: string,
-					) {
-						const available = yield* executableAvailable(executable, root)
-						add({
-							id,
-							category: id.startsWith("tool.") ? "tool" : "integration",
-							level,
-							status: available ? "pass" : "fail",
-							message: available
-								? `${label} executable '${executable}' is available`
-								: `${label} executable '${executable}' is unavailable`,
-							remediation:
-								level === "optional"
-									? `Install '${executable}' to enable ${label.toLowerCase()}, or leave it unavailable if unused.`
-									: `Install '${executable}' and ensure it is executable on PATH.`,
+					) =>
+						Effect.gen(function* () {
+							const available = yield* executableAvailable(executable, root)
+							add({
+								id,
+								category: id.startsWith("tool.") ? "tool" : "integration",
+								level,
+								status: available ? "pass" : "fail",
+								message: available
+									? `${label} executable '${executable}' is available`
+									: `${label} executable '${executable}' is unavailable`,
+								remediation:
+									level === "optional"
+										? `Install '${executable}' to enable ${label.toLowerCase()}, or leave it unavailable if unused.`
+										: `Install '${executable}' and ensure it is executable on PATH.`,
+							})
+							return available
 						})
-						return available
-					}
 
-					const gitAvailable = yield* tool("tool.git", "git", "error", "Git")
-					const jjAvailable = yield* tool(
-						"tool.jj",
-						"jj",
-						config.vcs === "jj" ? "error" : "optional",
-						"Jujutsu",
+					const [gitAvailable, jjAvailable] = yield* Effect.all(
+						[
+							tool("tool.git", "git", "error", "Git"),
+							tool(
+								"tool.jj",
+								"jj",
+								config.vcs === "jj" ? "error" : "optional",
+								"Jujutsu",
+							),
+						],
+						{ concurrency: "unbounded", batching: true },
 					)
 					const versionControlAvailable =
 						gitAvailable && (config.vcs !== "jj" || jjAvailable)
-					yield* tool(
-						"capability.agent.opencode",
-						"opencode",
-						"optional",
-						"OpenCode agent",
-					)
-					yield* tool(
-						"capability.agent.claude",
-						"claude",
-						"optional",
-						"Claude agent",
+					yield* Effect.all(
+						[
+							tool(
+								"capability.agent.opencode",
+								"opencode",
+								"optional",
+								"OpenCode agent",
+							),
+							tool(
+								"capability.agent.claude",
+								"claude",
+								"optional",
+								"Claude agent",
+							),
+						],
+						{ concurrency: "unbounded", batching: true },
 					)
 
 					const configuredCommands: readonly (readonly [
@@ -250,11 +257,16 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 								]
 							: []),
 					]
-					for (const [id, command, label] of configuredCommands) {
-						yield* tool(id, command[0]!, "error", label)
-					}
+					yield* Effect.all(
+						configuredCommands.map(([id, command, label]) =>
+							tool(id, command[0]!, "error", label),
+						),
+						{ concurrency: 16, batching: true },
+					)
 
-					const validation = yield* workbases.validate(root)
+					const validation = yield* workbases.validate(root, {
+						includeDocuments: true,
+					})
 					add({
 						id: "workbase.validation",
 						category: "workbase",
@@ -267,7 +279,7 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							"Run 'agency validate' and correct every reported issue.",
 					})
 
-					for (const [id, mode, level, label, remediation] of [
+					const permissionChecks = [
 						[
 							"permission.workbase.read",
 							constants.R_OK,
@@ -282,8 +294,16 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 							"writable",
 							`Grant the current user write access to ${root} before running mutation commands.`,
 						],
-					] as const) {
-						const available = yield* permissionAvailable(root, mode)
+					] as const
+					const permissionResults = yield* Effect.all(
+						permissionChecks.map(([, mode]) => permissionAvailable(root, mode)),
+						{ concurrency: "unbounded", batching: true },
+					)
+					for (const [
+						index,
+						[id, , level, label, remediation],
+					] of permissionChecks.entries()) {
+						const available = permissionResults[index]!
 						add({
 							id,
 							category: "permission",
@@ -321,12 +341,12 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 						values.add(ref)
 						refs.set(repo, values)
 					}
-					if (validation.valid) {
-						for (const epic of yield* epics.list(root)) {
+					if (validation.valid && validation.documents) {
+						for (const epic of validation.documents.epics) {
 							for (const reference of epic.data.repos)
 								declareRef(reference.repo, reference.ref)
 						}
-						for (const task of yield* tasks.list(root)) {
+						for (const task of validation.documents.tasks) {
 							if ("review" in task.data) {
 								declareRef(task.data.review.repo, task.data.review.commit)
 								reviewSources.push({
@@ -344,7 +364,9 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 								for (const reference of task.data.repos ?? [])
 									declareRef(reference.repo, reference.ref)
 							} else {
-								for (const phase of yield* phases.list(task.id, root)) {
+								for (const phase of validation.documents.phasesByTask.get(
+									task.id,
+								) ?? []) {
 									declareRef(phase.data.repo, phase.data.base)
 									for (const reference of phase.data.repos ?? [])
 										declareRef(reference.repo, reference.ref)
@@ -442,7 +464,36 @@ export class DoctorService extends Effect.Service<DoctorService>()(
 					}
 
 					if (validation.valid && versionControlAvailable) {
-						const inspected = yield* Effect.either(worktrees.list(root))
+						const tasks = validation.documents?.tasks.map(
+							(record) =>
+								({ ...record, content: "", revision: "" }) satisfies TaskRecord,
+						)
+						const phasesByTask = validation.documents
+							? new Map(
+									[...validation.documents.phasesByTask].map(
+										([taskId, records]) =>
+											[
+												taskId,
+												records.map(
+													(record) =>
+														({
+															...record,
+															taskId,
+															content: "",
+															revision: "",
+														}) satisfies PhaseRecord,
+												),
+											] as const,
+									),
+								)
+							: undefined
+						const inspected = yield* Effect.either(
+							worktrees.list(root, {
+								materializedOnly: true,
+								tasks,
+								phasesByTask,
+							}),
+						)
 						if (Either.isLeft(inspected)) {
 							add({
 								id: "worktree.inspection",

package/src/services/WorkbaseService.ts

@@ -56,6 +56,7 @@ export interface ValidationReport {
 	readonly taskCount: number
 	readonly phaseCount: number
 	readonly valid: boolean
+	readonly documents?: ValidationDocuments
 }
 
 interface DocumentRecord<T> {
@@ -64,6 +65,15 @@ interface DocumentRecord<T> {
 	readonly data: T
 }
 
+interface ValidationDocuments {
+	readonly epics: readonly DocumentRecord<EpicData>[]
+	readonly tasks: readonly DocumentRecord<TaskData>[]
+	readonly phasesByTask: ReadonlyMap<
+		string,
+		readonly DocumentRecord<PhaseData>[]
+	>
+}
+
 type DecodeResult<T> =
 	| { readonly success: true; readonly value: T }
 	| { readonly success: false; readonly error: string }
@@ -653,7 +663,10 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					),
 				),
 
-			validate: (startPath: string = process.cwd()) =>
+			validate: (
+				startPath: string = process.cwd(),
+				options: { readonly includeDocuments?: boolean } = {},
+			) =>
 				Effect.gen(function* () {
 					const service = yield* WorkbaseService
 					const fs = yield* FileSystemService
@@ -959,6 +972,14 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							: a.path.localeCompare(b.path),
 					)
 
+					const phasesByTask = new Map<string, DocumentRecord<PhaseData>[]>()
+					for (const [key, phase] of phases) {
+						const taskId = key.slice(0, key.indexOf("/"))
+						const records = phasesByTask.get(taskId) ?? []
+						records.push(phase)
+						phasesByTask.set(taskId, records)
+					}
+
 					return {
 						root,
 						issues,
@@ -966,6 +987,15 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 						taskCount: tasks.size,
 						phaseCount: phases.size,
 						valid: issues.length === 0,
+						...(options.includeDocuments
+							? {
+									documents: {
+										epics: [...epics.values()],
+										tasks: [...tasks.values()],
+										phasesByTask,
+									},
+								}
+							: {}),
 					} satisfies ValidationReport
 				}),
 		}),