@markjaquith/agency 2.11.0 → 2.13.0

package/src/services/GraphService.test.ts

@@ -154,12 +154,33 @@ describe("GraphService", () => {
 		)!
 		const verify = graph.nodes.find((node) => node.id === "phase:ship/verify")!
 		expect(prepare.dependents).toEqual(["task:ship"])
-		expect(ship.readiness).toMatchObject({ ready: true, blocked: false })
+		expect(prepare.readiness).toMatchObject({
+			ready: false,
+			terminal: true,
+		})
+		expect(ship.readiness).toMatchObject({
+			ready: true,
+			blocked: false,
+			terminal: false,
+		})
+		expect(ship.aggregate).toMatchObject({ total: 2, open: 2, terminal: 0 })
 		expect(implement.dependents).toEqual(["phase:ship/verify"])
 		expect(implement.readiness).toMatchObject({ ready: true, blocked: false })
+		expect(
+			graph.nodes.find(
+				(node) => node.id === "execution-unit:phase/ship/implement",
+			)?.readiness,
+		).toMatchObject({
+			ready: true,
+			blocked: false,
+			blockedBy: [],
+			terminal: false,
+		})
 		expect(verify.readiness).toMatchObject({
 			ready: false,
 			blocked: true,
+			blockedBy: ["phase:ship/implement"],
+			terminal: false,
 			blockers: [
 				{
 					kind: "dependency",
@@ -168,6 +189,8 @@ describe("GraphService", () => {
 				},
 			],
 		})
+		const epic = graph.nodes.find((node) => node.id === "epic:delivery")!
+		expect(epic.aggregate).toMatchObject({ total: 3, done: 1, open: 2 })
 		expect(graph.summary).toEqual({
 			status: "open",
 			total: 3,
@@ -181,6 +204,36 @@ describe("GraphService", () => {
 		expect(await getGraph(root)).toEqual(graph)
 	})
 
+	test("never reports claimed or terminal execution units as ready", async () => {
+		const root = await createWorkbase()
+		roots.push(root)
+		const path = "tasks/ship/phases/implement/PHASE.md"
+
+		for (const status of ["working", "delegated", "done", "dropped"]) {
+			await write(
+				root,
+				path,
+				`---
+repo: agency
+branch: feat/implement
+base: main
+pr: null
+status: ${status}
+---
+
+# Implement
+`,
+			)
+			const graph = await getGraph(root, {
+				kinds: ["execution-unit"],
+				ready: true,
+			})
+			expect(graph.nodes.map((node) => node.key)).not.toContain(
+				"phase/ship/implement",
+			)
+		}
+	})
+
 	test("applies filters after computing graph state", async () => {
 		const root = await createWorkbase()
 		roots.push(root)
@@ -235,6 +288,7 @@ status: open
 					reason: "Unlisted phase 'orphan'",
 				},
 			],
+			blockedBy: ["tasks/ship/TASK.md"],
 		})
 	})
 

package/src/services/GraphService.ts

@@ -12,9 +12,13 @@ import {
 	type GraphNode,
 	type GraphNodeKind,
 	type GraphPr,
-	type GraphProgress,
 	type GraphRepositoryGit,
 } from "../graph-schema"
+import {
+	aggregateProgress,
+	isDependencySatisfied,
+	readinessState,
+} from "../readiness"
 import { parseFrontmatter } from "../workbase/frontmatter"
 import {
 	EpicFrontmatter,
@@ -69,33 +73,6 @@ const taskExecutionNodeId = (taskId: string) => `execution-unit:task/${taskId}`
 const phaseExecutionNodeId = (taskId: string, phaseId: string) =>
 	`execution-unit:phase/${taskId}/${phaseId}`
 
-const progress = (statuses: readonly WorkStatus[]): GraphProgress => {
-	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(
-			(status) => status === "done" || status === "dropped",
-		).length,
-	}
-	const status: WorkStatus =
-		statuses.length === 0
-			? "open"
-			: statuses.every((value) => value === "done")
-				? "done"
-				: statuses.every((value) => value === "done" || value === "dropped")
-					? "dropped"
-					: statuses.includes("working")
-						? "working"
-						: statuses.includes("delegated")
-							? "delegated"
-							: "open"
-	return { status, ...counts }
-}
-
 const hash = (content: string) =>
 	new Bun.CryptoHasher("sha256").update(content).digest("hex")
 
@@ -256,7 +233,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 							: [task.data.status]
 					}
 					const taskStatus = (taskId: string) =>
-						progress(taskLeafStatuses(taskId)).status
+						aggregateProgress(taskLeafStatuses(taskId)).status
 					const dependencyBlockers = (
 						dependencies: readonly string[],
 						toId: (id: string) => string,
@@ -265,7 +242,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 					): GraphBlocker[] =>
 						dependencies.flatMap((dependency) => {
 							const value = status(dependency)
-							return value === "done"
+							return isDependencySatisfied(value)
 								? []
 								: [
 										{
@@ -336,10 +313,9 @@ export class GraphService extends Effect.Service<GraphService>()(
 						}
 						return {
 							status,
-							aggregate: progress([status]),
+							aggregate: aggregateProgress([status]),
 							readiness: {
-								ready: status === "open" && blockers.length === 0,
-								blocked: status === "open" && blockers.length > 0,
+								...readinessState(status, blockers),
 								blockers: uniqueBlockers(blockers),
 							},
 						}
@@ -348,7 +324,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 					const taskState = (taskId: string) => {
 						const task = tasks.get(taskId)
 						const statuses = taskLeafStatuses(taskId)
-						const aggregate = progress(statuses)
+						const aggregate = aggregateProgress(statuses)
 						const descendantPaths = task
 							? [
 									relative(root, task.path),
@@ -410,8 +386,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 							status: aggregate.status,
 							aggregate,
 							readiness: {
-								ready,
-								blocked: !ready && taskBlockers.length > 0,
+								...readinessState(aggregate.status, taskBlockers, ready),
 								blockers: taskBlockers,
 							},
 						}
@@ -422,7 +397,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						const statuses =
 							epic?.data.tasks.flatMap((item) => taskLeafStatuses(item.id)) ??
 							[]
-						const aggregate = progress(statuses)
+						const aggregate = aggregateProgress(statuses)
 						const paths = epic
 							? [
 									relative(root, epic.path),
@@ -467,8 +442,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 							status: aggregate.status,
 							aggregate,
 							readiness: {
-								ready,
-								blocked: !ready && epicBlockers.length > 0,
+								...readinessState(aggregate.status, epicBlockers, ready),
 								blockers: epicBlockers,
 							},
 						}
@@ -874,7 +848,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 						includes,
 						nodes: filteredNodes,
 						edges: filteredEdges,
-						summary: progress(leafStatuses),
+						summary: aggregateProgress(leafStatuses),
 						validation: {
 							valid: validation.valid,
 							issues: validation.issues,

package/src/services/PhaseService.ts

@@ -15,6 +15,7 @@ import {
 	formatMarkdownDocument,
 	parseFrontmatter,
 } from "../workbase/frontmatter"
+import { canTransitionStatus } from "../readiness"
 
 class PhaseError extends Data.TaggedError("PhaseError")<{
 	readonly message: string
@@ -340,6 +341,11 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					const service = yield* PhaseService
 					const validStatus = yield* decodeStatus(status)
 					const record = yield* service.show(taskId, id, startPath)
+					if (!canTransitionStatus(record.data.status, validStatus)) {
+						return yield* new PhaseError({
+							message: `Cannot transition phase '${id}' from ${record.data.status} to ${validStatus}; reopen it first`,
+						})
+					}
 					const parsed = yield* parseFrontmatter(record.content, record.path)
 					const data = { ...record.data, status: validStatus }
 					const content = formatMarkdownDocument(data, parsed.body)

package/src/services/TaskPhaseService.test.ts

@@ -244,6 +244,22 @@ describe("task and phase services", () => {
 		expect(task.data.status).toBe("delegated")
 		expect(task.content).toContain("status: delegated")
 		expect(task.content).toContain("Describe the task outcome.")
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("single-status", "done", root),
+				),
+			),
+		)
+		await expect(
+			runTestEffect(
+				TaskService.pipe(
+					Effect.flatMap((service) =>
+						service.setStatus("single-status", "dropped", root),
+					),
+				),
+			),
+		).rejects.toThrow("reopen it first")
 
 		await runTestEffect(
 			TaskService.pipe(
@@ -283,6 +299,33 @@ describe("task and phase services", () => {
 			),
 		)
 		expect(phase.data.status).toBe("dropped")
+		await expect(
+			runTestEffect(
+				PhaseService.pipe(
+					Effect.flatMap((service) =>
+						service.setStatus("multi-status", "implementation", "done", root),
+					),
+				),
+			),
+		).rejects.toThrow("reopen it first")
+		await runTestEffect(
+			PhaseService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("multi-status", "implementation", "open", root),
+				),
+			),
+		)
+		expect(
+			(
+				await runTestEffect(
+					PhaseService.pipe(
+						Effect.flatMap((service) =>
+							service.setStatus("multi-status", "implementation", "done", root),
+						),
+					),
+				)
+			).data.status,
+		).toBe("done")
 		await expect(
 			runTestEffect(
 				TaskService.pipe(

package/src/services/TaskService.ts

@@ -15,6 +15,7 @@ import {
 	formatMarkdownDocument,
 	parseFrontmatter,
 } from "../workbase/frontmatter"
+import { canTransitionStatus } from "../readiness"
 
 class TaskError extends Data.TaggedError("TaskError")<{
 	readonly message: string
@@ -212,6 +213,11 @@ export class TaskService extends Effect.Service<TaskService>()("TaskService", {
 						message: `Task '${id}' has multiple phases; set status on a phase instead`,
 					})
 				}
+				if (!canTransitionStatus(record.data.status, validStatus)) {
+					return yield* new TaskError({
+						message: `Cannot transition task '${id}' from ${record.data.status} to ${validStatus}; reopen it first`,
+					})
+				}
 				const parsed = yield* parseFrontmatter(record.content, record.path)
 				const data = { ...record.data, status: validStatus }
 				const content = formatMarkdownDocument(data, parsed.body)

package/src/services/WorktreeService.test.ts

@@ -113,15 +113,17 @@ describe("WorktreeService", () => {
 			["remote", "set-url", "origin", join(root, "missing")],
 			join(root, "repos/agency"),
 		)
-		await expect(
-			runTestEffect(
-				WorktreeService.pipe(
-					Effect.flatMap((service) =>
-						service.materialize("existing", undefined, root),
-					),
+		const reused = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("existing", undefined, root),
 				),
 			),
-		).resolves.toMatchObject({ repo: "agency" })
+		)
+		expect(reused.checkouts).toEqual([
+			expect.objectContaining({ repo: "agency", action: "reused" }),
+		])
+		expect(reused.operations).toEqual([])
 	})
 
 	test("reuses an immutable reference checkout without fetching", async () => {
@@ -771,6 +773,79 @@ pr: null
 			"refs/heads/task/removable",
 		])
 		expect(branch.exitCode).toBe(0)
+		expect(workspace.checkouts).toEqual([
+			expect.objectContaining({
+				repo: "agency",
+				kind: "writable",
+				action: "created",
+				resolvedCommit: expect.stringMatching(/^[0-9a-f]{40}$/),
+			}),
+			expect.objectContaining({
+				repo: "effect",
+				kind: "reference",
+				action: "created",
+				resolvedCommit: expect.stringMatching(/^[0-9a-f]{40}$/),
+			}),
+		])
+	})
+
+	test("reports dry-run fetch and worktree changes without mutating", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "planned",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/planned",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		const workspace = await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("planned", undefined, root, { dryRun: true }),
+				),
+			),
+		)
+
+		expect(workspace.dryRun).toBe(true)
+		expect(
+			workspace.checkouts.every(({ resolvedCommit }) => resolvedCommit),
+		).toBe(true)
+		expect(
+			workspace.checkouts.map(({ repo, action }) => ({ repo, action })),
+		).toEqual([
+			{ repo: "agency", action: "created" },
+			{ repo: "effect", action: "created" },
+		])
+		expect(workspace.operations).toEqual(
+			expect.arrayContaining([
+				expect.objectContaining({ action: "fetch", status: "planned" }),
+				expect.objectContaining({
+					action: "create-worktree",
+					status: "planned",
+				}),
+			]),
+		)
+		expect(await Bun.file(workspace.codePath).exists()).toBe(false)
+		expect(
+			Bun.spawnSync([
+				"git",
+				"-C",
+				join(root, "repos/agency"),
+				"show-ref",
+				"--verify",
+				"refs/heads/task/planned",
+			]).exitCode,
+		).not.toBe(0)
 	})
 
 	test("refuses to remove a worktree with uncommitted changes", async () => {