@markjaquith/agency 2.38.0 → 2.38.1

package/package.json

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

package/src/commands/status.ts

@@ -26,6 +26,7 @@ export const status = (options: StatusOptions = {}) =>
 		const executionRows = report.valid
 			? (yield* getWorkViews({
 					cwd,
+					validation: report,
 					statuses: options.statuses,
 					repositories: options.repositories,
 					ready: options.ready,

package/src/services/ContextService.ts

@@ -264,47 +264,90 @@ export class ContextService extends Effect.Service<ContextService>()(
 						const entries = (yield* fs.readDirectory(taskRoot))
 							.filter((entry) => entry.isDirectory)
 							.sort((a, b) => a.name.localeCompare(b.name))
-						for (const entry of entries) {
-							const path = join(taskRoot, entry.name, "TASK.md")
-							if (!(yield* fs.exists(path))) continue
-							const content = yield* fs.readFile(path)
-							const parsed = yield* Effect.either(
-								parseFrontmatter(content, path),
-							)
-							if (Either.isLeft(parsed)) continue
-							const decoded = decode(TaskFrontmatter, parsed.right.data)
-							if (!decoded.ok) continue
-							taskDocuments.set(entry.name, {
-								id: entry.name,
-								path,
-								sha256: documentRevision(content),
-								data: decoded.value,
-								body: parsed.right.body,
-							})
-							const phasesPath = join(taskRoot, entry.name, "phases")
-							if (!(yield* fs.isDirectory(phasesPath))) continue
-							for (const phaseEntry of (yield* fs.readDirectory(phasesPath))
-								.filter((item) => item.isDirectory)
-								.sort((a, b) => a.name.localeCompare(b.name))) {
-								const phasePath = join(phasesPath, phaseEntry.name, "PHASE.md")
-								if (!(yield* fs.exists(phasePath))) continue
-								const phaseContent = yield* fs.readFile(phasePath)
-								const phaseParsed = yield* Effect.either(
-									parseFrontmatter(phaseContent, phasePath),
-								)
-								if (Either.isLeft(phaseParsed)) continue
-								const phaseDecoded = decode(
-									PhaseFrontmatter,
-									phaseParsed.right.data,
+						const documents = yield* Effect.all(
+							entries.map((entry) =>
+								Effect.gen(function* () {
+									const path = join(taskRoot, entry.name, "TASK.md")
+									let taskDocument: Document<TaskData> | null = null
+									if (yield* fs.exists(path)) {
+										const content = yield* fs.readFile(path)
+										const parsed = yield* Effect.either(
+											parseFrontmatter(content, path),
+										)
+										if (Either.isRight(parsed)) {
+											const decoded = decode(TaskFrontmatter, parsed.right.data)
+											if (decoded.ok) {
+												taskDocument = {
+													id: entry.name,
+													path,
+													sha256: documentRevision(content),
+													data: decoded.value,
+													body: parsed.right.body,
+												}
+											}
+										}
+									}
+
+									const phasesPath = join(taskRoot, entry.name, "phases")
+									if (!(yield* fs.isDirectory(phasesPath))) {
+										return { taskDocument, phaseDocuments: [] }
+									}
+									const phaseEntries = (yield* fs.readDirectory(phasesPath))
+										.filter((item) => item.isDirectory)
+										.sort((a, b) => a.name.localeCompare(b.name))
+									const childDocuments = yield* Effect.all(
+										phaseEntries.map((phaseEntry) =>
+											Effect.gen(function* () {
+												const phasePath = join(
+													phasesPath,
+													phaseEntry.name,
+													"PHASE.md",
+												)
+												if (!(yield* fs.exists(phasePath))) return null
+												const content = yield* fs.readFile(phasePath)
+												const parsed = yield* Effect.either(
+													parseFrontmatter(content, phasePath),
+												)
+												if (Either.isLeft(parsed)) return null
+												const decoded = decode(
+													PhaseFrontmatter,
+													parsed.right.data,
+												)
+												if (!decoded.ok) return null
+												return [
+													`${entry.name}/${phaseEntry.name}`,
+													{
+														id: phaseEntry.name,
+														path: phasePath,
+														sha256: documentRevision(content),
+														data: decoded.value,
+														body: parsed.right.body,
+													},
+												] as const
+											}),
+										),
+										{ concurrency: "unbounded" },
+									)
+									return {
+										taskDocument,
+										phaseDocuments: childDocuments.filter(
+											(document): document is NonNullable<typeof document> =>
+												document !== null,
+										),
+									}
+								}),
+							),
+							{ concurrency: "unbounded" },
+						)
+						for (const document of documents) {
+							if (document.taskDocument) {
+								taskDocuments.set(
+									document.taskDocument.id,
+									document.taskDocument,
 								)
-								if (!phaseDecoded.ok) continue
-								phaseDocuments.set(`${entry.name}/${phaseEntry.name}`, {
-									id: phaseEntry.name,
-									path: phasePath,
-									sha256: documentRevision(phaseContent),
-									data: phaseDecoded.value,
-									body: phaseParsed.right.body,
-								})
+							}
+							for (const [key, phaseDocument] of document.phaseDocuments) {
+								phaseDocuments.set(key, phaseDocument)
 							}
 						}
 					}

package/src/services/GraphService.ts

@@ -33,7 +33,7 @@ import {
 	type WorkStatus,
 } from "../workbase/schemas"
 import { FileSystemService } from "./FileSystemService"
-import { WorkbaseService } from "./WorkbaseService"
+import { WorkbaseService, type ValidationReport } from "./WorkbaseService"
 
 class GraphError extends Data.TaggedError("GraphError")<{
 	readonly message: string
@@ -58,6 +58,7 @@ type ExecutionData = PhaseData | Extract<TaskData, { readonly repo: string }>
 
 export interface GraphOptions {
 	readonly cwd?: string
+	readonly validation?: ValidationReport
 	readonly ready?: boolean
 	readonly blocked?: boolean
 	readonly statuses?: readonly WorkStatus[]
@@ -166,34 +167,64 @@ export class GraphService extends Effect.Service<GraphService>()(
 							} satisfies Document<Schema.Schema.Type<S>>
 						})
 
-					for (const id of yield* directories(join(root, "epics"))) {
-						const path = join(root, "epics", id, "EPIC.md")
-						if (yield* fs.exists(path)) {
-							epics.set(id, yield* readDocument(id, path, EpicFrontmatter))
-						}
+					const epicIds = yield* directories(join(root, "epics"))
+					const epicDocuments = yield* Effect.all(
+						epicIds.map((id) =>
+							Effect.gen(function* () {
+								const path = join(root, "epics", id, "EPIC.md")
+								return (yield* fs.exists(path))
+									? yield* readDocument(id, path, EpicFrontmatter)
+									: null
+							}),
+						),
+						{ concurrency: "unbounded" },
+					)
+					for (const document of epicDocuments) {
+						if (document) epics.set(document.id, document)
 					}
-					for (const id of yield* directories(join(root, "tasks"))) {
-						const path = join(root, "tasks", id, "TASK.md")
-						if (yield* fs.exists(path)) {
-							tasks.set(id, yield* readDocument(id, path, TaskFrontmatter))
-						}
-						for (const phaseId of yield* directories(
-							join(root, "tasks", id, "phases"),
-						)) {
-							const phasePath = join(
-								root,
-								"tasks",
-								id,
-								"phases",
-								phaseId,
-								"PHASE.md",
-							)
-							if (yield* fs.exists(phasePath)) {
-								phases.set(
-									`${id}/${phaseId}`,
-									yield* readDocument(phaseId, phasePath, PhaseFrontmatter),
+
+					const taskIds = yield* directories(join(root, "tasks"))
+					const taskDocuments = yield* Effect.all(
+						taskIds.map((id) =>
+							Effect.gen(function* () {
+								const path = join(root, "tasks", id, "TASK.md")
+								const task = (yield* fs.exists(path))
+									? yield* readDocument(id, path, TaskFrontmatter)
+									: null
+								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* fs.exists(phasePath))
+												? yield* readDocument(
+														phaseId,
+														phasePath,
+														PhaseFrontmatter,
+													)
+												: null
+										}),
+									),
+									{ concurrency: "unbounded" },
+								)
+								return { id, task, phases: taskPhases }
+							}),
+						),
+						{ concurrency: "unbounded" },
+					)
+					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)
 						}
 					}
 
@@ -262,7 +293,8 @@ export class GraphService extends Effect.Service<GraphService>()(
 									]
 						})
 
-					const validation = yield* workbase.validate(root)
+					const validation =
+						options.validation ?? (yield* workbase.validate(root))
 					const validationBlockers = (
 						paths: readonly string[],
 					): GraphBlocker[] =>

package/src/services/WorkbaseService.ts

@@ -45,7 +45,7 @@ interface ValidationIssue {
 	readonly message: string
 }
 
-interface ValidationReport {
+export interface ValidationReport {
 	readonly root: string
 	readonly issues: readonly ValidationIssue[]
 	readonly epicCount: number
@@ -634,34 +634,64 @@ export class WorkbaseService extends Effect.Service<WorkbaseService>()(
 							return decoded.value
 						})
 
-					for (const id of yield* readDirectories(join(root, "epics"))) {
-						const path = join(root, "epics", id, "EPIC.md")
-						const data = yield* readDocument(path, EpicFrontmatter)
-						if (data) {
-							epics.set(id, { id, path, data })
-						}
+					const epicIds = yield* readDirectories(join(root, "epics"))
+					const epicDocuments = yield* Effect.all(
+						epicIds.map((id) =>
+							Effect.gen(function* () {
+								const path = join(root, "epics", id, "EPIC.md")
+								const data = yield* readDocument(path, EpicFrontmatter)
+								return data ? { id, path, data } : null
+							}),
+						),
+						{ concurrency: "unbounded" },
+					)
+					for (const document of epicDocuments) {
+						if (document) epics.set(document.id, document)
 					}
 
-					for (const id of yield* readDirectories(join(root, "tasks"))) {
-						const taskPath = join(root, "tasks", id)
-						const path = join(taskPath, "TASK.md")
-						const data = yield* readDocument(path, TaskFrontmatter)
-						if (data) {
-							tasks.set(id, { id, path, data })
-						}
-
-						for (const phaseId of yield* readDirectories(
-							join(taskPath, "phases"),
-						)) {
-							const phasePath = join(taskPath, "phases", phaseId, "PHASE.md")
-							const phase = yield* readDocument(phasePath, PhaseFrontmatter)
-							if (phase) {
-								phases.set(`${id}/${phaseId}`, {
-									id: phaseId,
-									path: phasePath,
-									data: phase,
-								})
-							}
+					const taskIds = yield* readDirectories(join(root, "tasks"))
+					const taskDocuments = yield* Effect.all(
+						taskIds.map((id) =>
+							Effect.gen(function* () {
+								const taskPath = join(root, "tasks", id)
+								const path = join(taskPath, "TASK.md")
+								const data = yield* readDocument(path, TaskFrontmatter)
+								const phaseIds = yield* readDirectories(
+									join(taskPath, "phases"),
+								)
+								const taskPhases = yield* Effect.all(
+									phaseIds.map((phaseId) =>
+										Effect.gen(function* () {
+											const phasePath = join(
+												taskPath,
+												"phases",
+												phaseId,
+												"PHASE.md",
+											)
+											const phase = yield* readDocument(
+												phasePath,
+												PhaseFrontmatter,
+											)
+											return phase
+												? { id: phaseId, path: phasePath, data: phase }
+												: null
+										}),
+									),
+									{ concurrency: "unbounded" },
+								)
+								return {
+									id,
+									task: data ? { id, path, data } : null,
+									phases: taskPhases,
+								}
+							}),
+						),
+						{ concurrency: "unbounded" },
+					)
+					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)
 						}
 					}
 

package/src/work-view.ts

@@ -1,6 +1,7 @@
 import { Effect } from "effect"
 import type { GraphNode } from "./graph-schema"
 import { GraphService } from "./services/GraphService"
+import type { ValidationReport } from "./services/WorkbaseService"
 import type { WorkStatus } from "./workbase/schemas"
 
 type WorkNode = Extract<
@@ -12,6 +13,7 @@ type ExecutionNode = Extract<WorkNode, { readonly kind: "execution-unit" }>
 
 export interface WorkViewOptions {
 	readonly cwd?: string
+	readonly validation?: ValidationReport
 	readonly statuses?: readonly string[]
 	readonly repositories?: readonly string[]
 	readonly ready?: boolean
@@ -170,6 +172,7 @@ export const getWorkViews = (options: WorkViewOptions = {}) =>
 		)
 		const graph = yield* graphService.get({
 			cwd: options.cwd,
+			validation: options.validation,
 			include: ["workspace"],
 		})
 		const workNodes = graph.nodes.filter(