@markjaquith/agency 2.71.17 → 2.71.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.17",
+  "version": "2.71.18",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -75,6 +75,7 @@
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:claim": "bun scripts/benchmark-claim.ts",
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
+    "benchmark:epic": "bun scripts/benchmark-epic.ts",
     "benchmark:phase": "bun scripts/benchmark-phase.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:archive": "bun scripts/benchmark-archive.ts",

package/src/commands/epic.test.ts

@@ -111,6 +111,35 @@ describe("epic command", () => {
 		})
 	})
 
+	test("reads each epic document once when listing JSON", async () => {
+		await runTestEffect(
+			epic({
+				subcommand: "create",
+				args: ["example"],
+				ticketUrl: "https://example.com/epic",
+				repos: ["agency:main"],
+				cwd: root,
+				silent: true,
+			}),
+		)
+		const original = Bun.file
+		let reads = 0
+		Bun.file = ((path: Parameters<typeof Bun.file>[0], ...args: never[]) => {
+			if (String(path).endsWith("/epics/example/EPIC.md")) reads += 1
+			return original(path as unknown as string, ...args)
+		}) as typeof Bun.file
+		try {
+			await captureLogs(() =>
+				runTestEffect(
+					epic({ subcommand: "list", args: [], cwd: root, json: true }),
+				),
+			)
+		} finally {
+			Bun.file = original
+		}
+		expect(reads).toBe(2)
+	})
+
 	test("renders a readable operational table", async () => {
 		await runTestEffect(
 			epic({

package/src/commands/epic.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import { join } from "node:path"
 import type { BaseCommandOptions } from "../utils/command"
 import { EpicService } from "../services/EpicService"
 import { createLoggers } from "../utils/effect"
@@ -71,7 +72,6 @@ export const epic = (options: EpicOptions, work: StartWork = startWork) =>
 			}
 
 			case "list": {
-				const records = yield* epics.list(cwd)
 				const { epicRows } = yield* getWorkViews({
 					cwd,
 					statuses: options.statuses,
@@ -80,14 +80,15 @@ export const epic = (options: EpicOptions, work: StartWork = startWork) =>
 					blocked: options.blocked,
 					pr: options.pr,
 				})
-				const ordered = epicRows.flatMap((row) => {
-					const record = records.find((item) => item.id === row.key)
-					return record ? [record] : []
-				})
 				if (options.json) {
 					log(
 						JSON.stringify(
-							ordered.map(({ content: _, ...record }) => record),
+							epicRows.map((row) => ({
+								id: row.id,
+								path: join(cwd, "epics", row.id, "EPIC.md"),
+								revision: row.revision,
+								data: row.data,
+							})),
 							null,
 							2,
 						),

package/src/readiness.ts

@@ -24,23 +24,27 @@ export const canTransitionStatus = (from: WorkStatus, to: WorkStatus) =>
 export const aggregateProgress = (statuses: readonly WorkStatus[]) => {
 	const counts = {
 		total: statuses.length,
-		open: statuses.filter((status) => status === "open").length,
-		working: statuses.filter((status) => status === "working").length,
-		delegated: statuses.filter((status) => status === "delegated").length,
-		done: statuses.filter((status) => status === "done").length,
-		dropped: statuses.filter((status) => status === "dropped").length,
-		terminal: statuses.filter(isTerminalStatus).length,
+		open: 0,
+		working: 0,
+		delegated: 0,
+		done: 0,
+		dropped: 0,
+		terminal: 0,
+	}
+	for (const status of statuses) {
+		counts[status] += 1
+		if (isTerminalStatus(status)) counts.terminal += 1
 	}
 	const status: WorkStatus =
-		statuses.length === 0
+		counts.total === 0
 			? "open"
-			: statuses.every((value) => value === "done")
+			: counts.done === counts.total
 				? "done"
-				: statuses.every(isTerminalStatus)
+				: counts.terminal === counts.total
 					? "dropped"
-					: statuses.includes("working")
+					: counts.working > 0
 						? "working"
-						: statuses.includes("delegated")
+						: counts.delegated > 0
 							? "delegated"
 							: "open"
 	return { status, ...counts }

package/src/services/GraphService.ts

@@ -298,22 +298,28 @@ export class GraphService extends Effect.Service<GraphService>()(
 					}
 					const taskDependencies = (taskId: string) =>
 						taskDeclarations.get(taskId)?.dependsOn ?? []
+					const taskLeafStatusCache = new Map<string, WorkStatus[]>()
 					const taskLeafStatuses = (taskId: string): WorkStatus[] => {
+						const cached = taskLeafStatusCache.get(taskId)
+						if (cached) return cached
 						const task = tasks.get(taskId)
 						if (!task) return []
-						return "phases" in task.data
-							? task.data.phases.map(
-									(item) =>
-										phases.get(`${taskId}/${item.id}`)?.data.status ?? "open",
-								)
-							: [task.data.status]
+						const statuses =
+							"phases" in task.data
+								? task.data.phases.map(
+										(item) =>
+											phases.get(`${taskId}/${item.id}`)?.data.status ?? "open",
+									)
+								: [task.data.status]
+						taskLeafStatusCache.set(taskId, statuses)
+						return statuses
 					}
-					const taskStatuses = new Map<string, WorkStatus>()
+					const taskStatusCache = new Map<string, WorkStatus>()
 					const taskStatus = (taskId: string) => {
-						const cached = taskStatuses.get(taskId)
+						const cached = taskStatusCache.get(taskId)
 						if (cached) return cached
 						const status = aggregateProgress(taskLeafStatuses(taskId)).status
-						taskStatuses.set(taskId, status)
+						taskStatusCache.set(taskId, status)
 						return status
 					}
 					const dependencyBlockers = (

package/src/work-view.ts

@@ -34,6 +34,7 @@ export interface WorkViewRow {
 	readonly pr: string
 	readonly worktree: string
 	readonly hasPr: boolean
+	readonly data: Readonly<Record<string, unknown>>
 }
 
 const allowedStatuses = new Set<WorkStatus>([
@@ -122,6 +123,9 @@ const rowFor = (
 		hasPr: executions.some(
 			(execution) => "pr" in execution.data && Boolean(execution.data.pr),
 		),
+		data: Object.fromEntries(
+			Object.entries(node.data).filter(([key]) => key !== "sha256"),
+		),
 	}
 }