@markjaquith/agency 2.71.16 → 2.71.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.16",
+  "version": "2.71.18",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -75,8 +75,10 @@
     "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",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",
     "benchmark:validate": "bun scripts/benchmark-validate.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/ArchiveBulkService.test.ts

@@ -121,6 +121,35 @@ describe("ArchiveService bulk task archive", () => {
 		)
 	})
 
+	test("reuses loaded records while preflighting task worktrees", async () => {
+		for (const id of ["first", "second"]) {
+			await createTask(id)
+			await dropTask(id)
+		}
+		let taskReads = 0
+		const file = Bun.file(join(root, "tasks/first/TASK.md"))
+		const prototype = Object.getPrototypeOf(file) as {
+			text: () => Promise<string>
+			name: string
+		}
+		const originalText = prototype.text
+		prototype.text = function () {
+			if (this.name.endsWith("/TASK.md")) taskReads += 1
+			return originalText.call(this)
+		}
+
+		try {
+			const result = await archiveTasks(true)
+			expect(result.tasks.map((task) => task.disposition)).toEqual([
+				"planned",
+				"planned",
+			])
+			expect(taskReads).toBe(10)
+		} finally {
+			prototype.text = originalText
+		}
+	})
+
 	test("uses aggregate phase status and archives only when every phase is terminal", async () => {
 		await runTestEffect(
 			TaskService.pipe(

package/src/services/ArchiveService.ts

@@ -887,7 +887,10 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 							})
 							continue
 						}
+					}
 
+					for (const context of contexts.values()) {
+						if (skipped.has(context.task.id)) continue
 						const removed: string[] = []
 						let preflightFailure: unknown
 						for (const unit of context.executionUnits) {
@@ -895,6 +898,10 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 								.remove(unit.taskId, executionPhaseId(unit), root, {
 									dryRun: true,
 									persistResume: false,
+									task: context.task,
+									phase: unit.phaseId
+										? context.phases.find((phase) => phase.id === unit.phaseId)
+										: undefined,
 								})
 								.pipe(Effect.either)
 							if (Either.isLeft(result)) {
@@ -943,13 +950,13 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 										"dirty" in conflict &&
 										conflict.dirty === true,
 								)
-							skipped.set(task.id, {
+							skipped.set(context.task.id, {
 								code: dirty ? "dirty-worktree" : "checkout-preflight-failed",
 								details: [message],
 							})
 							continue
 						}
-						removedByTask.set(task.id, [...new Set(removed)].sort())
+						removedByTask.set(context.task.id, [...new Set(removed)].sort())
 					}
 
 					const cohort = new Set(
@@ -1069,6 +1076,14 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 													snapshots,
 													lockHeld: true,
 													persistResume: false,
+													task: contexts.get(unit.taskId)!.task,
+													phase: unit.phaseId
+														? contexts
+																.get(unit.taskId)!
+																.phases.find(
+																	(phase) => phase.id === unit.phaseId,
+																)
+														: undefined,
 												}),
 											)
 										}

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/services/WorktreeService.ts

@@ -284,6 +284,8 @@ interface RemoveOptions extends BaseCommandOptions {
 	readonly lockHeld?: boolean
 	readonly allowReferenceDrift?: boolean
 	readonly persistResume?: boolean
+	readonly task?: TaskRecord
+	readonly phase?: PhaseRecord
 }
 
 interface LifecycleOptions extends BaseCommandOptions {
@@ -1575,14 +1577,14 @@ const removeJj = (
 		const phases = yield* PhaseService
 		const backend = yield* versionControl.forWorkbase(root)
 		const inspection = yield* inspectExecution(taskId, phaseId, root)
-		const task = yield* tasks.show(taskId, root)
+		const task = options.task ?? (yield* tasks.show(taskId, root))
 		const execution =
 			"phases" in task.data && phaseId
-				? (yield* phases.show(taskId, phaseId, root)).data
+				? (options.phase ?? (yield* phases.show(taskId, phaseId, root))).data
 				: task.data
 		const phasePath =
 			"phases" in task.data && phaseId
-				? (yield* phases.show(taskId, phaseId, root)).path
+				? (options.phase ?? (yield* phases.show(taskId, phaseId, root))).path
 				: null
 		const resumePath = jjResumePath(task.path, phasePath)
 		if (yield* fs.exists(resumePath)) {
@@ -2909,7 +2911,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 											conflicts: blockingConflicts,
 										})
 									}
-									const task = yield* tasks.show(taskId, root)
+									const task = options.task ?? (yield* tasks.show(taskId, root))
 
 									let execution:
 										| {
@@ -2925,7 +2927,9 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 												message: `Task '${taskId}' has multiple phases; phase ID is required`,
 											})
 										}
-										const phase = yield* phases.show(taskId, phaseId, root)
+										const phase =
+											options.phase ??
+											(yield* phases.show(taskId, phaseId, root))
 										execution = phase.data
 										codePath = join(dirname(phase.path), "code")
 									} else {

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"),
+		),
 	}
 }