@markjaquith/agency 2.48.1 → 2.50.0

package/src/services/PhaseService.ts

@@ -26,6 +26,10 @@ import {
 	type TransactionStep,
 } from "./LifecycleTransaction"
 import { withWorktreeLocks } from "./WorktreeLock"
+import {
+	buildNonPrCompletion,
+	type NonPrCompletionInput,
+} from "../workbase/completion"
 
 class PhaseError extends Data.TaggedError("PhaseError")<{
 	readonly message: string
@@ -93,6 +97,11 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 					const taskId = yield* decodeId(input.taskId, "task")
 					const id = yield* decodeId(input.id, "phase")
 					const task = yield* tasks.show(taskId, root)
+					if ("review" in task.data) {
+						return yield* new PhaseError({
+							message: `Review task '${taskId}' cannot be converted to phases`,
+						})
+					}
 					const isMultiPhase = "phases" in task.data
 					let firstPhaseId: string | undefined
 					if (!isMultiPhase) {
@@ -221,6 +230,9 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							pr: task.data.pr,
 							status: task.data.status,
 							...(task.data.claim ? { claim: task.data.claim } : {}),
+							...(task.data.completion
+								? { completion: task.data.completion }
+								: {}),
 						})
 						const firstTitle = firstPhaseId!
 							.split("-")
@@ -469,6 +481,7 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 				id: string,
 				status: string,
 				startPath: string = process.cwd(),
+				nonPrCompletion?: NonPrCompletionInput,
 			) =>
 				Effect.gen(function* () {
 					const fs = yield* FileSystemService
@@ -486,11 +499,41 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							message: `Phase '${id}' has an active claim; use agency release or agency finish`,
 						})
 					}
-					if (!canTransitionStatus(record.data.status, validStatus)) {
+					if (nonPrCompletion && validStatus !== "done") {
+						return yield* new PhaseError({
+							message: "Non-PR completion is valid only with a done status",
+						})
+					}
+					if (nonPrCompletion && record.data.pr !== null) {
+						return yield* new PhaseError({
+							message:
+								"Cannot complete without a pull request while an authoritative pull request is recorded",
+						})
+					}
+					const completionResult = nonPrCompletion
+						? buildNonPrCompletion(nonPrCompletion, new Date())
+						: undefined
+					if (completionResult && "error" in completionResult) {
+						return yield* new PhaseError({ message: completionResult.error })
+					}
+					if (
+						completionResult &&
+						record.data.status !== "open" &&
+						record.data.status !== "working" &&
+						record.data.status !== "delegated"
+					) {
+						return yield* new PhaseError({
+							message: `Cannot transition phase '${id}' from ${record.data.status} to done; reopen it first`,
+						})
+					}
+					if (
+						!canTransitionStatus(record.data.status, validStatus) &&
+						!completionResult
+					) {
 						if (validStatus === "done") {
 							return yield* new PhaseError({
 								message:
-									"Work becomes done after its authoritative pull request is merged; run 'agency sync --apply'",
+									"Work becomes done after its authoritative pull request is merged; run 'agency sync --apply', or explicitly complete a non-PR outcome with '--no-pull-request --summary <text>'",
 							})
 						}
 						return yield* new PhaseError({
@@ -498,7 +541,16 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 						})
 					}
 					const parsed = yield* parseFrontmatter(record.content, record.path)
-					const data = { ...record.data, status: validStatus }
+					const { completion: _, ...withoutCompletion } = record.data
+					const data: PhaseData = completionResult
+						? {
+								...record.data,
+								status: "done",
+								completion: completionResult.value,
+							}
+						: validStatus === "open"
+							? { ...withoutCompletion, status: validStatus }
+							: { ...record.data, status: validStatus }
 					const content = formatMarkdownDocument(data, parsed.body)
 					yield* fs.writeFile(record.path, content)
 					return {

package/src/services/PullRequestService.test.ts

@@ -279,6 +279,26 @@ process.exit(${exitCode})
 		expect(await createPullRequest("example", undefined, false, true)).toBe(url)
 	})
 
+	test("requires reopening non-PR completed work even when forced", async () => {
+		await createTask()
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.setStatus("example", "done", root, {
+						summary: "Investigation completed without changes.",
+					}),
+				),
+			),
+		)
+
+		await expect(
+			createPullRequest("example", undefined, false, true),
+		).rejects.toThrow("Reopen non-PR completed work")
+		expect(
+			await Bun.file(join(root, "tasks/example/code/agency")).exists(),
+		).toBe(false)
+	})
+
 	test("updates only PHASE.md for a phase PR", async () => {
 		await runTestEffect(
 			TaskService.pipe(
@@ -333,7 +353,7 @@ process.exit(${exitCode})
 	test("blocks a dirty checkout before push or gh", async () => {
 		await createTask()
 		const workspace = await materialize()
-		await Bun.write(join(workspace.writablePath, "dirty.txt"), "dirty\n")
+		await Bun.write(join(workspace.writablePath!, "dirty.txt"), "dirty\n")
 		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
 
 		await expect(createPullRequest()).rejects.toThrow(
@@ -498,7 +518,7 @@ process.stdout.write(${JSON.stringify(JSON.stringify(providerRecord))})
 	test("reports git status failure before push or gh", async () => {
 		await createTask()
 		const workspace = await materialize()
-		await rm(join(workspace.writablePath, ".git"))
+		await rm(join(workspace.writablePath!, ".git"))
 		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/48" })
 
 		await expect(createPullRequest()).rejects.toThrow(

package/src/services/PullRequestService.ts

@@ -50,6 +50,11 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					const phases = yield* PhaseService
 					const root = yield* workbase.discover(startPath)
 					const task = yield* tasks.show(taskId, root)
+					if ("review" in task.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot record a delivery pull request`,
+						})
+					}
 					const target =
 						"phases" in task.data
 							? phaseId
@@ -58,6 +63,12 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 										message: `Task '${taskId}' requires a phase ID`,
 									})
 							: task
+					if ("completion" in target.data && target.data.completion) {
+						return yield* new PullRequestError({
+							message:
+								"Reopen non-PR completed work before recording a pull request",
+						})
+					}
 					const parsed = yield* parseFrontmatter(target.content, target.path)
 					yield* fs.writeFile(
 						target.path,
@@ -99,6 +110,26 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 					const worktrees = yield* WorktreeService
 					const readiness = yield* ReadinessService
 					const workbase = yield* WorkbaseService
+					const requestedTask = yield* tasks.show(taskId, startPath)
+					if ("review" in requestedTask.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot create a delivery pull request`,
+						})
+					}
+					const target =
+						"phases" in requestedTask.data
+							? phaseId
+								? yield* phases.show(taskId, phaseId, startPath)
+								: yield* new PullRequestError({
+										message: `Task '${taskId}' requires a phase ID`,
+									})
+							: requestedTask
+					if ("completion" in target.data && target.data.completion) {
+						return yield* new PullRequestError({
+							message:
+								"Reopen non-PR completed work before creating a pull request",
+						})
+					}
 					yield* readiness.guard(
 						"pr",
 						taskId,
@@ -112,12 +143,22 @@ export class PullRequestService extends Effect.Service<PullRequestService>()(
 						startPath,
 						options,
 					)
-					const task = yield* tasks.show(taskId, workspace.root)
+					const workspaceTask = yield* tasks.show(taskId, workspace.root)
+					if ("review" in workspaceTask.data) {
+						return yield* new PullRequestError({
+							message: `Review task '${taskId}' cannot create a delivery pull request`,
+						})
+					}
 					const execution =
-						"phases" in task.data
+						"phases" in workspaceTask.data
 							? (yield* phases.show(taskId, phaseId!, workspace.root)).data
-							: task.data
+							: workspaceTask.data
 					const { config } = yield* workbase.loadConfig(workspace.root)
+					if (!workspace.writablePath) {
+						return yield* new PullRequestError({
+							message: `Task '${taskId}' has no writable checkout`,
+						})
+					}
 					const remote = config.delivery?.remote ?? "origin"
 
 					const status = yield* fs.runCommand(

package/src/services/ReadinessService.ts

@@ -77,7 +77,7 @@ const itemFor = (
 			? task.data.epic
 			: undefined
 	const dependentIds = new Set(node.dependents)
-	if (node.data.phaseId) {
+	if ("phaseId" in node.data && node.data.phaseId) {
 		const siblings = graph.nodes.filter(
 			(candidate): candidate is ExecutionNode =>
 				candidate.kind === "execution-unit" &&
@@ -93,10 +93,14 @@ const itemFor = (
 		rank,
 		key: node.key,
 		taskId: node.data.taskId,
-		...(node.data.phaseId ? { phaseId: node.data.phaseId } : {}),
+		...("phaseId" in node.data && node.data.phaseId
+			? { phaseId: node.data.phaseId }
+			: {}),
 		...(node.data.description ? { description: node.data.description } : {}),
 		parent: {
-			...(node.data.phaseId ? { taskId: node.data.taskId } : {}),
+			...("phaseId" in node.data && node.data.phaseId
+				? { taskId: node.data.taskId }
+				: {}),
 			...(epicId ? { epicId } : {}),
 		},
 		status: node.status,