@markjaquith/agency 2.34.1 → 2.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.34.1",
+  "version": "2.35.0",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",

package/src/cli.test.ts

@@ -862,6 +862,19 @@ status: open
 			await runGit(["-C", source, "remote", "add", "origin", daemon.remote])
 
 			parseJson(await runCli(["init", root, "--json"], parent))
+			const agencyConfigPath = join(root, "agency.json")
+			const agencyConfig = JSON.parse(await Bun.file(agencyConfigPath).text())
+			await Bun.write(
+				agencyConfigPath,
+				`${JSON.stringify(
+					{
+						...agencyConfig,
+						runners: { noop: { command: ["true"] } },
+					},
+					null,
+					2,
+				)}\n`,
+			)
 			parseJson(
 				await runCli(["repo", "link", "agency", source, "--json"], root),
 			)
@@ -1066,6 +1079,61 @@ status: open
 					}
 				}
 			}
+
+			parseJson(
+				await runCli(["task", "status", "example", "done", "--json"], root),
+			)
+			const blocked = await runCli(
+				["work", "--task", "example", "--runner", "noop"],
+				root,
+			)
+			expect(blocked.exitCode).toBe(1)
+			expect(blocked.stderr).toContain("Task status is done")
+			expect(
+				parseJson(await runCli(["task", "show", "example", "--json"], root))
+					.data.status,
+			).toBe("done")
+
+			const resumedTask = await runCli(
+				["work", "--task", "example", "--runner", "noop", "--force"],
+				root,
+			)
+			expect(resumedTask).toMatchObject({ exitCode: 0, stderr: "" })
+			expect(resumedTask.stdout).toContain(
+				"Reopened task/example from done as working",
+			)
+			expect(
+				parseJson(await runCli(["task", "show", "example", "--json"], root))
+					.data.status,
+			).toBe("working")
+
+			parseJson(
+				await runCli(
+					["phase", "status", "pipeline", "build", "dropped", "--json"],
+					root,
+				),
+			)
+			const resumedPhase = await runCli(
+				[
+					"work",
+					"--task",
+					"pipeline",
+					"--phase",
+					"build",
+					"--runner",
+					"noop",
+					"--force",
+				],
+				root,
+			)
+			expect(resumedPhase).toMatchObject({ exitCode: 0, stderr: "" })
+			expect(resumedPhase.stdout).toContain(
+				"Reopened phase/pipeline/build from dropped as working",
+			)
+			const graph = parseJson(await runCli(["graph", "--json"], root))
+			expect(
+				graph.nodes.find((node: any) => node.id === "task:pipeline").status,
+			).toBe("working")
 		},
 		30_000,
 	)

package/src/commands/work.test.ts

@@ -69,10 +69,17 @@ interface HarnessOptions {
 	readonly registeredWorkbases?: readonly string[]
 	readonly existingDirectories?: readonly string[]
 	readonly guardError?: Error
+	readonly launchError?: Error
 	readonly workTargetIds?: readonly string[]
 	readonly opencodeIntegrationState?: "managed" | "customized"
 	readonly taskStatus?: "open" | "working" | "delegated" | "done" | "dropped"
 	readonly phaseStatus?: "open" | "working" | "delegated" | "done" | "dropped"
+	readonly taskStatuses?: Readonly<
+		Record<string, "open" | "working" | "delegated" | "done" | "dropped">
+	>
+	readonly phaseStatuses?: Readonly<
+		Record<string, "open" | "working" | "delegated" | "done" | "dropped">
+	>
 }
 
 const createHarness = (options: HarnessOptions = {}) => {
@@ -92,6 +99,8 @@ const createHarness = (options: HarnessOptions = {}) => {
 	const materializeOptions: Array<
 		Parameters<WorktreeService["materialize"]>[3]
 	> = []
+	const taskStatuses = { ...options.taskStatuses }
+	const phaseStatuses = { ...options.phaseStatuses }
 	const worktrees = {
 		materialize: (
 			_taskId: string,
@@ -147,13 +156,19 @@ const createHarness = (options: HarnessOptions = {}) => {
 							repo: "agency",
 							branch: `task/${id}`,
 							base: "main",
-							status: options.taskStatus ?? "open",
+							status: taskStatuses[id] ?? options.taskStatus ?? "open",
 						},
 			})
 		},
 		list: () => Effect.succeed(options.taskRecords ?? []),
 		setStatus: (id: string, status: string) => {
 			statusUpdates.push(`task:${id}:${status}`)
+			taskStatuses[id] = status as
+				| "open"
+				| "working"
+				| "delegated"
+				| "done"
+				| "dropped"
 			return Effect.void
 		},
 	}
@@ -167,12 +182,19 @@ const createHarness = (options: HarnessOptions = {}) => {
 					repo: "agency",
 					branch: `task/${id}`,
 					base: "main",
-					status: options.phaseStatus ?? "open",
+					status:
+						phaseStatuses[`${taskId}/${id}`] ?? options.phaseStatus ?? "open",
 				},
 			}),
 		list: () => Effect.succeed(options.phaseRecords ?? []),
 		setStatus: (taskId: string, id: string, status: string) => {
 			statusUpdates.push(`phase:${taskId}:${id}:${status}`)
+			phaseStatuses[`${taskId}/${id}`] = status as
+				| "open"
+				| "working"
+				| "delegated"
+				| "done"
+				| "dropped"
 			return Effect.void
 		},
 	}
@@ -241,6 +263,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 		events.push(`launch:${cli}`)
 		launches.push({ cli, args, cwd })
 		launchEnvironments.push(environment)
+		if (options.launchError) throw options.launchError
 	}
 	const defaultPick: PickWorkTarget = () => Effect.succeed(null)
 	const defaultPickWorkbase: PickWorkbase = () => Effect.succeed(null)
@@ -284,6 +307,8 @@ const createHarness = (options: HarnessOptions = {}) => {
 		launchEnvironments,
 		materializeOptions,
 		statusUpdates,
+		taskStatuses,
+		phaseStatuses,
 		shownTasks,
 		progressUpdates,
 		guards,
@@ -328,6 +353,72 @@ describe("work command", () => {
 		})
 	})
 
+	test("reopens forced terminal tasks through open before launching as working", async () => {
+		for (const previousStatus of ["done", "dropped"] as const) {
+			const harness = createHarness({
+				taskStatuses: { example: previousStatus },
+			})
+			const output = await captureLogs(() =>
+				harness.run({ taskId: "example", opencode: true, force: true }),
+			)
+
+			expect(harness.statusUpdates).toEqual([
+				"task:example:open",
+				"task:example:working",
+			])
+			expect(harness.taskStatuses.example).toBe("working")
+			expect(output).toEqual([
+				`Reopened task/example from ${previousStatus} as working`,
+			])
+		}
+	})
+
+	test("reopens forced terminal phases through open before launching as working", async () => {
+		for (const previousStatus of ["done", "dropped"] as const) {
+			const harness = createHarness({
+				workspace: multiPhaseWorkspace,
+				multiPhaseTasks: ["example"],
+				phaseStatuses: { "example/implementation": previousStatus },
+			})
+			const output = await captureLogs(() =>
+				harness.run({
+					taskId: "example",
+					phaseId: "implementation",
+					opencode: true,
+					force: true,
+				}),
+			)
+
+			expect(harness.statusUpdates).toEqual([
+				"phase:example:implementation:open",
+				"phase:example:implementation:working",
+			])
+			expect(harness.phaseStatuses["example/implementation"]).toBe("working")
+			expect(output).toEqual([
+				`Reopened phase/example/implementation from ${previousStatus} as working`,
+			])
+		}
+	})
+
+	test("reports a forced reopen as one machine result", async () => {
+		const harness = createHarness({ taskStatuses: { example: "done" } })
+		const output = await captureLogs(() =>
+			harness.run({
+				taskId: "example",
+				opencode: true,
+				force: true,
+				json: true,
+			}),
+		)
+
+		expect(JSON.parse(output.join("\n"))).toEqual({
+			target: "task/example",
+			reopened: true,
+			previousStatus: "done",
+			status: "working",
+		})
+	})
+
 	test("offers only launchable targets to the interactive chooser", async () => {
 		const harness = createHarness({
 			taskRecords: [
@@ -425,7 +516,7 @@ describe("work command", () => {
 			opencode: true,
 		})
 
-		expect(harness.shownTasks).toEqual(["delivery"])
+		expect(harness.shownTasks).toEqual(["delivery", "delivery"])
 		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 	})
 
@@ -438,7 +529,7 @@ describe("work command", () => {
 			opencode: true,
 		})
 
-		expect(harness.shownTasks).toEqual(["delivery"])
+		expect(harness.shownTasks).toEqual(["delivery", "delivery"])
 		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
 	})
 
@@ -829,6 +920,22 @@ describe("work command", () => {
 		expect(printed.environment.API_TOKEN).toBeUndefined()
 	})
 
+	test("does not reopen a forced terminal target in print-only mode", async () => {
+		const harness = createHarness({ taskStatuses: { example: "done" } })
+
+		await captureLogs(() =>
+			harness.run({
+				taskId: "example",
+				opencode: true,
+				force: true,
+				printCommand: true,
+			}),
+		)
+
+		expect(harness.statusUpdates).toEqual([])
+		expect(harness.taskStatuses.example).toBe("done")
+	})
+
 	test("prints the runtime OpenCode integration config", async () => {
 		const harness = createHarness()
 		const output = await captureLogs(() =>
@@ -933,6 +1040,35 @@ describe("work command", () => {
 		])
 	})
 
+	test("does not reopen a terminal target when preparation fails", async () => {
+		const harness = createHarness({
+			taskStatuses: { example: "dropped" },
+			materializeError: new Error("materialization failed"),
+		})
+
+		await expect(
+			harness.run({ taskId: "example", force: true }),
+		).rejects.toThrow("materialization failed")
+		expect(harness.statusUpdates).toEqual([])
+		expect(harness.taskStatuses.example).toBe("dropped")
+	})
+
+	test("retains working when launch fails after a forced reopen", async () => {
+		const harness = createHarness({
+			taskStatuses: { example: "done" },
+			launchError: new Error("launch failed"),
+		})
+
+		await expect(
+			harness.run({ taskId: "example", force: true, silent: true }),
+		).rejects.toThrow("launch failed")
+		expect(harness.statusUpdates).toEqual([
+			"task:example:open",
+			"task:example:working",
+		])
+		expect(harness.taskStatuses.example).toBe("working")
+	})
+
 	test("respects silent and verbose logging options", async () => {
 		const verboseHarness = createHarness()
 		const verboseLogs = await captureErrors(() =>

package/src/commands/work.ts

@@ -12,6 +12,7 @@ import { IntegrationService } from "../services/IntegrationService"
 import { createLoggers } from "../utils/effect"
 import { execvp } from "../utils/exec"
 import { createProgress, type Progress } from "../utils/progress"
+import { isTerminalStatus } from "../readiness"
 import {
 	buildWorkTargetChoices,
 	pickWorkTarget,
@@ -379,9 +380,53 @@ export const work = (
 			return
 		}
 		if (target.kind === "phase") {
+			const previousStatus = (yield* phases.show(
+				target.taskId,
+				target.phaseId,
+				root,
+			)).data.status
+			if (options.force && isTerminalStatus(previousStatus)) {
+				yield* phases.setStatus(target.taskId, target.phaseId, "open", root)
+			}
 			yield* phases.setStatus(target.taskId, target.phaseId, "working", root)
+			if (options.force && isTerminalStatus(previousStatus)) {
+				const result = {
+					target: `phase/${target.taskId}/${target.phaseId}`,
+					reopened: true,
+					previousStatus,
+					status: "working",
+				}
+				log(
+					options.json
+						? JSON.stringify(result)
+						: `Reopened ${result.target} from ${previousStatus} as working`,
+				)
+			}
 		} else if (target.kind === "task" && !target.multiPhase) {
+			const task = yield* tasks.show(target.taskId, root)
+			if ("phases" in task.data) {
+				return yield* Effect.fail(
+					new Error(`Task '${target.taskId}' is not an execution unit`),
+				)
+			}
+			const previousStatus = task.data.status
+			if (options.force && isTerminalStatus(previousStatus)) {
+				yield* tasks.setStatus(target.taskId, "open", root)
+			}
 			yield* tasks.setStatus(target.taskId, "working", root)
+			if (options.force && isTerminalStatus(previousStatus)) {
+				const result = {
+					target: `task/${target.taskId}`,
+					reopened: true,
+					previousStatus,
+					status: "working",
+				}
+				log(
+					options.json
+						? JSON.stringify(result)
+						: `Reopened ${result.target} from ${previousStatus} as working`,
+				)
+			}
 		}
 		for (const [key, value] of Object.entries(environment)) {
 			process.env[key] = value
@@ -484,7 +529,7 @@ Options:
   --print-command      Print cwd, argv, and non-secret environment without launch
   --opencode           Require the OpenCode preset
   --claude             Require the Claude Code preset
-  --force              Override readiness and terminal-state guards
+  --force              Override readiness; reopen terminal execution units
   --no-input           Never open an interactive selector
 
 Without interactive input, provide an explicit workbase or cwd and an entity