@markjaquith/agency 2.71.14 → 2.71.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.71.14",
+  "version": "2.71.16",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -68,12 +68,14 @@
     "benchmark:pr": "bun scripts/benchmark-pr.ts",
     "benchmark:release": "bun scripts/benchmark-release.ts",
     "benchmark:status": "bun scripts/benchmark-status.ts",
+    "benchmark:next": "bun scripts/benchmark-next.ts",
     "benchmark:init": "bun scripts/benchmark-init.ts",
     "benchmark:workbase": "bun scripts/benchmark-workbase.ts",
     "benchmark:doctor": "bun scripts/benchmark-doctor.ts",
     "benchmark:context": "bun scripts/benchmark-context.ts",
     "benchmark:claim": "bun scripts/benchmark-claim.ts",
     "benchmark:finish": "bun scripts/benchmark-finish.ts",
+    "benchmark:phase": "bun scripts/benchmark-phase.ts",
     "benchmark:push": "bun scripts/benchmark-push.ts",
     "benchmark:sync": "bun scripts/benchmark-sync.ts",
     "benchmark:task": "bun scripts/benchmark-task.ts",

package/src/commands/task-phase.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { mkdir } from "node:fs/promises"
 import { join } from "node:path"
-import { Effect } from "effect"
+import { Effect, Layer } from "effect"
 import {
 	captureLogs,
 	cleanupTempDir,
@@ -10,6 +10,10 @@ import {
 } from "../test-utils"
 import { phase } from "./phase"
 import { task } from "./task"
+import { FileSystemService } from "../services/FileSystemService"
+import { PhaseService } from "../services/PhaseService"
+import { TaskService } from "../services/TaskService"
+import { WorkbaseService } from "../services/WorkbaseService"
 
 describe("task and phase command JSON output", () => {
 	let root: string
@@ -186,6 +190,45 @@ describe("task and phase command JSON output", () => {
 		})
 	})
 
+	test("shows one phase without reading sibling phase documents", async () => {
+		await runTestEffect(
+			phase({
+				subcommand: "create",
+				args: ["multi", "second"],
+				repo: "agency",
+				branch: "task/second",
+				base: "main",
+				cwd: root,
+				silent: true,
+			}),
+		)
+		const fs = await Effect.runPromise(
+			FileSystemService.pipe(Effect.provide(FileSystemService.Default)),
+		)
+		const readPaths: string[] = []
+		const countingFs = {
+			...fs,
+			readFile: (path: string) => {
+				readPaths.push(path)
+				return fs.readFile(path)
+			},
+		}
+		const program = PhaseService.pipe(
+			Effect.flatMap((service) => service.show("multi", "second", root)),
+			Effect.provide(PhaseService.Default),
+			Effect.provide(TaskService.Default),
+			Effect.provide(WorkbaseService.Default),
+			Effect.provide(Layer.succeed(FileSystemService, countingFs)),
+		)
+
+		const record = await Effect.runPromise(program)
+
+		expect(record.id).toBe("second")
+		expect(readPaths.filter((path) => path.endsWith("PHASE.md"))).toEqual([
+			join(root, "tasks/multi/phases/second/PHASE.md"),
+		])
+	})
+
 	test("renders task and phase operational tables", async () => {
 		const taskLogs = await captureLogs(() =>
 			runTestEffect(task({ subcommand: "list", args: [], cwd: root })),

package/src/services/GraphService.ts

@@ -339,7 +339,8 @@ export class GraphService extends Effect.Service<GraphService>()(
 						})
 
 					const validation =
-						options.validation ?? (yield* workbase.validate(root))
+						options.validation ??
+						(yield* workbase.validate(root, { includeDocuments: true }))
 					const validationIssuesByPath = Map.groupBy(
 						validation.issues,
 						(issue) => issue.path,

package/src/services/ReadinessService.ts

@@ -65,24 +65,19 @@ const isWorkTarget = (node: GraphNode) =>
 
 const itemFor = (
 	node: ExecutionNode,
-	graph: AgencyGraph,
+	tasks: ReadonlyMap<string, Extract<GraphNode, { readonly kind: "task" }>>,
+	executionsByTask: ReadonlyMap<string, readonly ExecutionNode[]>,
 	rank: number,
 ): NextItem => {
-	const task = graph.nodes.find(
-		(candidate) =>
-			candidate.kind === "task" && candidate.key === node.data.taskId,
-	)
+	const task = tasks.get(node.data.taskId)
 	const epicId =
 		task?.kind === "task" && typeof task.data.epic === "string"
 			? task.data.epic
 			: undefined
 	const dependentIds = new Set(node.dependents)
 	if ("phaseId" in node.data && node.data.phaseId) {
-		const siblings = graph.nodes.filter(
-			(candidate): candidate is ExecutionNode =>
-				candidate.kind === "execution-unit" &&
-				candidate.data.taskId === node.data.taskId &&
-				candidate.id !== node.id,
+		const siblings = (executionsByTask.get(node.data.taskId) ?? []).filter(
+			(candidate) => candidate.id !== node.id,
 		)
 		if (siblings.every((sibling) => sibling.status === "done")) {
 			for (const dependent of task?.dependents ?? [])
@@ -113,16 +108,27 @@ const itemFor = (
 	}
 }
 
-const rankedItems = (graph: AgencyGraph) =>
-	graph.nodes
-		.filter((node): node is ExecutionNode => node.kind === "execution-unit")
-		.map((node) => itemFor(node, graph, 0))
+const rankedItems = (graph: AgencyGraph) => {
+	const tasks = new Map<string, Extract<GraphNode, { readonly kind: "task" }>>()
+	const executionsByTask = new Map<string, ExecutionNode[]>()
+	const executions: ExecutionNode[] = []
+	for (const node of graph.nodes) {
+		if (node.kind === "task") tasks.set(node.key, node)
+		if (node.kind !== "execution-unit") continue
+		executions.push(node)
+		const siblings = executionsByTask.get(node.data.taskId)
+		if (siblings) siblings.push(node)
+		else executionsByTask.set(node.data.taskId, [node])
+	}
+	return executions
+		.map((node) => itemFor(node, tasks, executionsByTask, 0))
 		.sort(
 			(left, right) =>
 				right.priority.dependentCount - left.priority.dependentCount ||
 				left.key.localeCompare(right.key),
 		)
 		.map((item, index) => ({ ...item, rank: index + 1 }))
+}
 
 const guardMessage = (
 	action: "work" | "pr",