@markjaquith/agency 2.71.10 → 2.71.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.10",
+  "version": "2.71.11",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -73,6 +73,7 @@
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",
+    "benchmark:validate": "bun scripts/benchmark-validate.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'",

package/src/services/WorkbaseService.test.ts

@@ -3,6 +3,7 @@ import { Effect } from "effect"
 import { mkdir, realpath, rm, symlink } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
 
 const write = async (root: string, path: string, content: string) => {
@@ -104,6 +105,65 @@ pr: null
 		expect(report.issues).toEqual([])
 	})
 
+	test("reads configuration and documents once during validation", async () => {
+		await write(
+			root,
+			"agency.json",
+			JSON.stringify({
+				version: 2,
+				repositories: {
+					agency: { remote: "https://example.com/agency.git" },
+				},
+			}),
+		)
+		await write(
+			root,
+			"tasks/example/TASK.md",
+			`---
+ticketUrl: null
+repo: agency
+branch: task/example
+base: main
+pr: null
+---
+`,
+		)
+
+		const fs = await Effect.runPromise(
+			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
+		)
+		const reads: string[] = []
+		const exists: string[] = []
+		const trackedFs = {
+			...fs,
+			readFile: (path: string) => {
+				reads.push(path)
+				return fs.readFile(path)
+			},
+			exists: (path: string) => {
+				exists.push(path)
+				return fs.exists(path)
+			},
+		}
+
+		const report = await Effect.runPromise(
+			WorkbaseService.pipe(
+				Effect.flatMap((service) => service.validate(root)),
+				Effect.provide(WorkbaseService.Default),
+				Effect.provideService(FileSystemService, trackedFs),
+			) as Effect.Effect<unknown, unknown, never>,
+		)
+
+		expect(report).toMatchObject({ valid: true, taskCount: 1 })
+		expect(
+			reads.filter((path) => path === join(root, "agency.json")),
+		).toHaveLength(2)
+		expect(
+			reads.filter((path) => path === join(root, "tasks/example/TASK.md")),
+		).toHaveLength(1)
+		expect(exists).not.toContain(join(root, "tasks/example/TASK.md"))
+	})
+
 	test("validates non-PR completion invariants without rejecting legacy done work", async () => {
 		await write(
 			root,

package/src/services/WorkbaseService.ts

@@ -65,6 +65,8 @@ interface DocumentRecord<T> {
 	readonly data: T
 }
 
+const validationConcurrency = 32
+
 interface ValidationDocuments {
 	readonly epics: readonly DocumentRecord<EpicData>[]
 	readonly tasks: readonly DocumentRecord<TaskData>[]
@@ -671,10 +673,23 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 					const service = yield* WorkbaseService
 					const fs = yield* FileSystemService
 					const root = yield* service.discover(startPath)
+					const configPath = join(root, "agency.json")
+					const configInput = JSON.parse(
+						yield* fs.readFile(configPath),
+					) as unknown
+					const configResult = decode(WorkbaseConfig, configInput)
+					if (!configResult.success) {
+						return yield* new WorkbaseConfigError({
+							path: configPath,
+							message: `Invalid workbase configuration in ${configPath}:\n${configResult.error}`,
+						})
+					}
+					const config = configResult.value
 					const issues: ValidationIssue[] = []
 					const epics = new Map<string, DocumentRecord<EpicData>>()
 					const tasks = new Map<string, DocumentRecord<TaskData>>()
 					const phases = new Map<string, DocumentRecord<PhaseData>>()
+					const phaseIdsByTask = new Map<string, Set<string>>()
 
 					const issue = (path: string, message: string) => {
 						issues.push({ path: relative(root, path) || ".", message })
@@ -691,7 +706,13 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							Effect.catchAll(() => Effect.succeed([])),
 						)
 
-					const aliases = new Set(yield* service.repositoryAliases(root))
+					const aliases = new Set(Object.keys(config.repositories ?? {}))
+					const reposPath = join(root, "repos")
+					if (yield* fs.isDirectory(reposPath)) {
+						for (const entry of yield* fs.readDirectory(reposPath)) {
+							if (!entry.name.startsWith(".agency-")) aliases.add(entry.name)
+						}
+					}
 
 					const readDocument = <S extends Schema.Schema.AnyNoContext>(
 						path: string,
@@ -728,7 +749,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								return data ? { id, path, data } : null
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: validationConcurrency },
 					)
 					for (const document of epicDocuments) {
 						if (document) epics.set(document.id, document)
@@ -744,6 +765,9 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								const phaseIds = yield* readDirectories(
 									join(taskPath, "phases"),
 								)
+								if (phaseIds.length > 0) {
+									phaseIdsByTask.set(id, new Set(phaseIds))
+								}
 								const taskPhases = yield* Effect.all(
 									phaseIds.map((phaseId) =>
 										Effect.gen(function* () {
@@ -762,7 +786,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 												: null
 										}),
 									),
-									{ concurrency: "unbounded" },
+									{ concurrency: validationConcurrency },
 								)
 								return {
 									id,
@@ -771,7 +795,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								}
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: validationConcurrency },
 					)
 					for (const documents of taskDocuments) {
 						if (documents.task) tasks.set(documents.id, documents.task)
@@ -922,10 +946,8 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							}
 						}
 
-						const phasePrefix = `${task.id}/`
-						const actualPhaseIds = [...phases.keys()]
-							.filter((key) => key.startsWith(phasePrefix))
-							.map((key) => key.slice(phasePrefix.length))
+						const actualPhaseIds =
+							phaseIdsByTask.get(task.id) ?? new Set<string>()
 
 						if ("phases" in task.data) {
 							const declaredIds = new Set(
@@ -952,7 +974,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							for (const cycle of findDependencyCycles(task.data.phases)) {
 								issue(task.path, `Phase dependency cycle includes '${cycle}'`)
 							}
-						} else if (actualPhaseIds.length > 0) {
+						} else if (actualPhaseIds.size > 0) {
 							issue(
 								task.path,
 								"Single-phase task cannot contain phase directories",