@markjaquith/agency 3.2.12 → 3.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.2.12",
+  "version": "3.2.13",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/commands/context.test.ts

@@ -1,12 +1,17 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test"
 import { mkdir, readFile as nodeReadFile, rename, rm } from "node:fs/promises"
 import { dirname, join } from "node:path"
+import { Effect } from "effect"
 import {
 	captureLogs,
 	cleanupTempDir,
 	createTempDir,
 	runTestEffect,
+	trackDocumentReadConcurrency,
 } from "../test-utils"
+import { documentLoadConcurrency } from "../workbase/document-loading"
+import { ContextService } from "../services/ContextService"
+import { FileSystemService } from "../services/FileSystemService"
 import { context } from "./context"
 
 const write = async (root: string, path: string, content: string) => {
@@ -157,6 +162,33 @@ Phase prose.
 		])
 	})
 
+	test("bounds document reads across nested task and phase traversal", async () => {
+		await Promise.all(
+			Array.from({ length: documentLoadConcurrency + 8 }, (_, index) =>
+				write(
+					root,
+					`tasks/agent-contract/phases/extra-${index}/PHASE.md`,
+					`---\nrepo: agency\nbranch: extra-${index}\nbase: main\npr: null\nstatus: open\n---\n`,
+				),
+			),
+		)
+		const fs = await Effect.runPromise(
+			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
+		)
+		const tracked = trackDocumentReadConcurrency(fs)
+
+		await runTestEffect(
+			ContextService.pipe(
+				Effect.flatMap((service) =>
+					service.get({ cwd: root, target: "foundations" }),
+				),
+				Effect.provideService(FileSystemService, tracked.fs),
+			),
+		)
+
+		expect(tracked.maximum()).toBe(documentLoadConcurrency)
+	})
+
 	afterEach(async () => {
 		await cleanupTempDir(root)
 	})

package/src/services/GraphService.test.ts

@@ -4,7 +4,14 @@ import { Effect } from "effect"
 import { mkdir } from "node:fs/promises"
 import { dirname, join } from "node:path"
 import { AgencyGraph } from "../graph-schema"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
+import {
+	cleanupTempDir,
+	createTempDir,
+	runTestEffect,
+	trackDocumentReadConcurrency,
+} from "../test-utils"
+import { documentLoadConcurrency } from "../workbase/document-loading"
+import { FileSystemService } from "./FileSystemService"
 import { GraphService } from "./GraphService"
 import {
 	VersionControlService,
@@ -209,6 +216,33 @@ describe("GraphService", () => {
 		expect(await getGraph(root)).toEqual(graph)
 	})
 
+	test("bounds document reads across nested task and phase traversal", async () => {
+		const root = await createWorkbase()
+		roots.push(root)
+		await Promise.all(
+			Array.from({ length: documentLoadConcurrency + 8 }, (_, index) =>
+				write(
+					root,
+					`tasks/ship/phases/extra-${index}/PHASE.md`,
+					`---\nrepo: agency\nbranch: extra-${index}\nbase: main\npr: null\nstatus: open\n---\n`,
+				),
+			),
+		)
+		const fs = await Effect.runPromise(
+			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
+		)
+		const tracked = trackDocumentReadConcurrency(fs)
+
+		await runTestEffect(
+			GraphService.pipe(
+				Effect.flatMap((service) => service.get({ cwd: root })),
+				Effect.provideService(FileSystemService, tracked.fs),
+			),
+		)
+
+		expect(tracked.maximum()).toBe(documentLoadConcurrency)
+	})
+
 	test("does not resolve a VCS backend when git details are not requested", async () => {
 		const root = await createWorkbase()
 		roots.push(root)

package/src/services/GraphService.ts

@@ -22,6 +22,7 @@ import {
 import { parseFrontmatter } from "../workbase/frontmatter"
 import { normalizePullRequestRecord } from "../workbase/delivery-command"
 import { documentRevision } from "../workbase/document-revision"
+import { documentLoadConcurrency } from "../workbase/document-loading"
 import {
 	EpicFrontmatter,
 	PhaseFrontmatter,
@@ -201,7 +202,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 								)
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: documentLoadConcurrency },
 					)
 					for (const document of epicDocuments) {
 						if (document) epics.set(document.id, document)
@@ -224,40 +225,37 @@ export class GraphService extends Effect.Service<GraphService>()(
 								const phaseIds = yield* directories(
 									join(root, "tasks", id, "phases"),
 								)
-								const taskPhases = yield* Effect.all(
-									phaseIds.map((phaseId) =>
-										Effect.gen(function* () {
-											const phasePath = join(
-												root,
-												"tasks",
-												id,
-												"phases",
-												phaseId,
-												"PHASE.md",
-											)
-											return yield* readDocument(
-												phaseId,
-												phasePath,
-												PhaseFrontmatter,
-											).pipe(
-												Effect.catchTag("FileNotFoundError", () =>
-													Effect.succeed(null),
-												),
-											)
-										}),
+								return { id, task, phaseIds }
+							}),
+						),
+						{ concurrency: documentLoadConcurrency },
+					)
+					const phaseDocuments = yield* Effect.all(
+						taskDocuments.flatMap(({ id, phaseIds }) =>
+							phaseIds.map((phaseId) => {
+								const phasePath = join(
+									root,
+									"tasks",
+									id,
+									"phases",
+									phaseId,
+									"PHASE.md",
+								)
+								return readDocument(phaseId, phasePath, PhaseFrontmatter).pipe(
+									Effect.catchTag("FileNotFoundError", () =>
+										Effect.succeed(null),
 									),
-									{ concurrency: "unbounded" },
+									Effect.map((document) => ({ taskId: id, document })),
 								)
-								return { id, task, phases: taskPhases }
 							}),
 						),
-						{ concurrency: "unbounded" },
+						{ concurrency: documentLoadConcurrency },
 					)
 					for (const documents of taskDocuments) {
 						if (documents.task) tasks.set(documents.id, documents.task)
-						for (const phase of documents.phases) {
-							if (phase) phases.set(`${documents.id}/${phase.id}`, phase)
-						}
+					}
+					for (const { taskId, document } of phaseDocuments) {
+						if (document) phases.set(`${taskId}/${document.id}`, document)
 					}
 
 					const repositoryRecords = new Map<string, RepositoryRecord>()

package/src/services/WorkbaseService.ts

@@ -26,6 +26,7 @@ import { validateAgents } from "../workbase/agent-command"
 import { findDependencyCycles } from "../workbase/dependency-graph"
 import { validateDelivery } from "../workbase/delivery-command"
 import { documentRevision } from "../workbase/document-revision"
+import { documentLoadConcurrency } from "../workbase/document-loading"
 
 class WorkbaseNotFoundError extends Data.TaggedError("WorkbaseNotFoundError")<{
 	readonly message: string
@@ -66,8 +67,6 @@ interface DocumentRecord<T> {
 	readonly data: T
 }
 
-const validationConcurrency = 32
-
 interface ValidationDocuments {
 	readonly epics: readonly DocumentRecord<EpicData>[]
 	readonly tasks: readonly DocumentRecord<TaskData>[]
@@ -751,7 +750,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								return document ? { id, path, ...document } : null
 							}),
 						),
-						{ concurrency: validationConcurrency },
+						{ concurrency: documentLoadConcurrency },
 					)
 					for (const document of epicDocuments) {
 						if (document) epics.set(document.id, document)
@@ -793,7 +792,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 												: null
 										}),
 									),
-									{ concurrency: validationConcurrency },
+									{ concurrency: documentLoadConcurrency },
 								)
 								return {
 									id,
@@ -802,7 +801,7 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 								}
 							}),
 						),
-						{ concurrency: validationConcurrency },
+						{ concurrency: documentLoadConcurrency },
 					)
 					for (const documents of taskDocuments) {
 						if (documents.task) tasks.set(documents.id, documents.task)

package/src/test-utils.ts

@@ -31,6 +31,26 @@ export const createTempDir = () => mkdtemp(join(tmpdir(), "agency-test-"))
 export const cleanupTempDir = (path: string) =>
 	rm(path, { recursive: true, force: true })
 
+export const trackDocumentReadConcurrency = (fs: FileSystemService) => {
+	let active = 0
+	let maximum = 0
+	return {
+		fs: {
+			...fs,
+			readFile: (path: string) => {
+				if (!/(?:EPIC|TASK|PHASE)\.md$/.test(path)) return fs.readFile(path)
+				return Effect.gen(function* () {
+					active += 1
+					maximum = Math.max(maximum, active)
+					yield* Effect.sleep(5)
+					return yield* fs.readFile(path)
+				}).pipe(Effect.ensuring(Effect.sync(() => (active -= 1))))
+			},
+		} satisfies FileSystemService,
+		maximum: () => maximum,
+	}
+}
+
 const TestLayer = Layer.mergeAll(
 	FileSystemService.Default,
 	WorkbaseService.Default,

package/src/workbase/document-loading.ts

@@ -0,0 +1 @@
+export const documentLoadConcurrency = 32