@markjaquith/agency 3.2.9 → 3.2.10

package/package.json

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

package/src/services/ArchiveService.ts

@@ -1,5 +1,5 @@
 import { Schema, TreeFormatter } from "@effect/schema"
-import { Data, Effect, Either, Layer } from "effect"
+import { Data, Effect, Either } from "effect"
 import { lstat, mkdir, open, rename, rm } from "node:fs/promises"
 import { dirname, join, relative, resolve, sep } from "node:path"
 import { EpicService, type EpicRecord } from "./EpicService"
@@ -40,6 +40,7 @@ import {
 	directoryMoveStep,
 	documentWriteStep,
 	runLifecycleTransaction,
+	transactionEffect,
 	type TransactionStep,
 } from "./LifecycleTransaction"
 import { withWorktreeLocks } from "./WorktreeLock"
@@ -358,21 +359,6 @@ const applyMutation = (moves: readonly Move[], writes: readonly Write[]) =>
 					}),
 	})
 
-const WorktreeLayer = Layer.mergeAll(
-	FileSystemService.Default,
-	WorkbaseService.Default,
-	GitVersionControlService.Default,
-	VersionControlService.Default,
-	TaskService.Default,
-	PhaseService.Default,
-	WorktreeService.Default,
-)
-
-const runWorktreeEffect = <A, E>(effect: Effect.Effect<A, E, any>) =>
-	Effect.runPromise(
-		effect.pipe(Effect.provide(WorktreeLayer)) as Effect.Effect<A, E, never>,
-	)
-
 const runGit = async (args: readonly string[]) => {
 	const process = Bun.spawn([...args], { stdout: "pipe", stderr: "pipe" })
 	const [exitCode, stdout, stderr] = await Promise.all([
@@ -791,25 +777,26 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					})
 					if (!options.dryRun) {
 						const snapshots: WorktreeRemovalSnapshot[] = []
-						const steps: TransactionStep[] = [
+						const steps: TransactionStep<any>[] = [
 							documentWriteStep(root, writes),
 							{
 								label: `remove worktrees for epic ${id}`,
-								apply: async () => {
-									try {
-										for (const unit of executionUnits)
-											await runWorktreeEffect(
-												worktrees.remove(unit.taskId, unit.phaseId, root, {
-													snapshots,
-													lockHeld: true,
-												}),
-											)
-									} catch (cause) {
-										await restoreWorktreeSnapshots(snapshots)
-										throw cause
-									}
-								},
-								rollback: () => restoreWorktreeSnapshots(snapshots),
+								apply: Effect.gen(function* () {
+									for (const unit of executionUnits)
+										yield* worktrees.remove(unit.taskId, unit.phaseId, root, {
+											snapshots,
+											lockHeld: true,
+										})
+								}).pipe(
+									Effect.catchAllCause((cause) =>
+										transactionEffect(() =>
+											restoreWorktreeSnapshots(snapshots),
+										).pipe(Effect.zipRight(Effect.failCause(cause))),
+									),
+								),
+								rollback: transactionEffect(() =>
+									restoreWorktreeSnapshots(snapshots),
+								),
 								manualRecovery: `Run agency work prepare for each execution unit in epic '${id}'`,
 							},
 						]
@@ -1074,34 +1061,33 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 						)
 					if (!options.dryRun && selected.length > 0) {
 						const snapshots: WorktreeRemovalSnapshot[] = []
-						const steps: TransactionStep[] = [
+						const steps: TransactionStep<any>[] = [
 							documentWriteStep(root, writes),
 							{
 								label: "remove worktrees for task archive cohort",
-								apply: async () => {
-									try {
-										for (const unit of executionUnits) {
-											await runWorktreeEffect(
-												worktrees.remove(unit.taskId, unit.phaseId, root, {
-													snapshots,
-													lockHeld: true,
-													task: contexts.get(unit.taskId)!.task,
-													phase: unit.phaseId
-														? contexts
-																.get(unit.taskId)!
-																.phases.find(
-																	(phase) => phase.id === unit.phaseId,
-																)
-														: undefined,
-												}),
-											)
-										}
-									} catch (cause) {
-										await restoreWorktreeSnapshots(snapshots)
-										throw cause
+								apply: Effect.gen(function* () {
+									for (const unit of executionUnits) {
+										yield* worktrees.remove(unit.taskId, unit.phaseId, root, {
+											snapshots,
+											lockHeld: true,
+											task: contexts.get(unit.taskId)!.task,
+											phase: unit.phaseId
+												? contexts
+														.get(unit.taskId)!
+														.phases.find((phase) => phase.id === unit.phaseId)
+												: undefined,
+										})
 									}
-								},
-								rollback: () => restoreWorktreeSnapshots(snapshots),
+								}).pipe(
+									Effect.catchAllCause((cause) =>
+										transactionEffect(() =>
+											restoreWorktreeSnapshots(snapshots),
+										).pipe(Effect.zipRight(Effect.failCause(cause))),
+									),
+								),
+								rollback: transactionEffect(() =>
+									restoreWorktreeSnapshots(snapshots),
+								),
 								manualRecovery:
 									"Run agency work prepare for each archived execution unit",
 							},
@@ -1281,30 +1267,31 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 					})
 					if (!options.dryRun) {
 						const snapshots: WorktreeRemovalSnapshot[] = []
-						const steps: TransactionStep[] = [
+						const steps: TransactionStep<any>[] = [
 							documentWriteStep(root, writes),
 							{
 								label: `remove worktrees for task ${id}`,
-								apply: async () => {
-									try {
-										for (const unit of executionUnits)
-											await runWorktreeEffect(
-												worktrees.remove(
-													unit.taskId,
-													executionPhaseId(unit),
-													root,
-													{
-														snapshots,
-														lockHeld: true,
-													},
-												),
-											)
-									} catch (cause) {
-										await restoreWorktreeSnapshots(snapshots)
-										throw cause
-									}
-								},
-								rollback: () => restoreWorktreeSnapshots(snapshots),
+								apply: Effect.gen(function* () {
+									for (const unit of executionUnits)
+										yield* worktrees.remove(
+											unit.taskId,
+											executionPhaseId(unit),
+											root,
+											{
+												snapshots,
+												lockHeld: true,
+											},
+										)
+								}).pipe(
+									Effect.catchAllCause((cause) =>
+										transactionEffect(() =>
+											restoreWorktreeSnapshots(snapshots),
+										).pipe(Effect.zipRight(Effect.failCause(cause))),
+									),
+								),
+								rollback: transactionEffect(() =>
+									restoreWorktreeSnapshots(snapshots),
+								),
 								manualRecovery: `Run agency work prepare for task '${id}'`,
 							},
 							directoryMoveStep(root, dirname(task.path), destination),
@@ -1426,15 +1413,22 @@ export class ArchiveService extends Effect.Service<ArchiveService>()(
 										documentWriteStep(root, writes),
 										{
 											label: `remove worktrees for phase ${taskId}/${id}`,
-											apply: async () => {
-												await runWorktreeEffect(
-													worktrees.remove(taskId, id, root, {
-														snapshots,
-														lockHeld: true,
-													}),
-												)
-											},
-											rollback: () => restoreWorktreeSnapshots(snapshots),
+											apply: worktrees
+												.remove(taskId, id, root, {
+													snapshots,
+													lockHeld: true,
+												})
+												.pipe(
+													Effect.asVoid,
+													Effect.catchAllCause((cause) =>
+														transactionEffect(() =>
+															restoreWorktreeSnapshots(snapshots),
+														).pipe(Effect.zipRight(Effect.failCause(cause))),
+													),
+												),
+											rollback: transactionEffect(() =>
+												restoreWorktreeSnapshots(snapshots),
+											),
 											manualRecovery: `Run agency work prepare for phase '${taskId}/${id}'`,
 										},
 										directoryMoveStep(root, dirname(phase.path), destination),

package/src/services/LifecycleTransaction.test.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
+import { Deferred, Effect, Fiber } from "effect"
 import { join } from "node:path"
 import { cleanupTempDir, createTempDir } from "../test-utils"
 import {
 	documentWriteStep,
 	runLifecycleTransaction,
+	transactionEffect,
 } from "./LifecycleTransaction"
 
 describe("lifecycle transactions", () => {
@@ -25,14 +26,16 @@ describe("lifecycle transactions", () => {
 					steps: [
 						{
 							label: "write marker",
-							apply: () => Bun.write(marker, "applied").then(() => undefined),
+							apply: transactionEffect(async () => {
+								await Bun.write(marker, "applied")
+							}),
 						},
 						{
 							label: "reject plan",
-							preflight: async () => {
+							preflight: Effect.sync(() => {
 								throw new Error("preflight rejected")
-							},
-							apply: async () => undefined,
+							}),
+							apply: Effect.void,
 						},
 					],
 				}),
@@ -57,9 +60,9 @@ describe("lifecycle transactions", () => {
 					]),
 					{
 						label: "fail after documents",
-						apply: async () => {
+						apply: Effect.sync(() => {
 							throw new Error("injected failure")
-						},
+						}),
 					},
 				],
 			}).pipe(Effect.either),
@@ -83,17 +86,17 @@ describe("lifecycle transactions", () => {
 				steps: [
 					{
 						label: "external mutation",
-						apply: async () => undefined,
-						rollback: async () => {
+						apply: Effect.void,
+						rollback: Effect.sync(() => {
 							throw new Error("rollback failed")
-						},
+						}),
 						manualRecovery: "undo external mutation",
 					},
 					{
 						label: "injected failure",
-						apply: async () => {
+						apply: Effect.sync(() => {
 							throw new Error("apply failed")
-						},
+						}),
 					},
 				],
 			}).pipe(Effect.either),
@@ -104,4 +107,39 @@ describe("lifecycle transactions", () => {
 		expect(failure.rolledBack).toEqual([])
 		expect(failure.manualRecovery).toEqual(["undo external mutation"])
 	})
+
+	test("waits for rollback and lock release when interrupted", async () => {
+		const events: string[] = []
+		const blocked = await Effect.runPromise(Deferred.make<void>())
+		const fiber = Effect.runFork(
+			runLifecycleTransaction({
+				root,
+				steps: [
+					{
+						label: "external mutation",
+						apply: Effect.sync(() => events.push("applied")),
+						rollback: transactionEffect(async () => {
+							events.push("rollback started")
+							await Bun.sleep(20)
+							events.push("rollback finished")
+						}),
+					},
+					{
+						label: "block",
+						apply: Deferred.succeed(blocked, undefined).pipe(
+							Effect.zipRight(Effect.never),
+						),
+					},
+				],
+			}),
+		)
+		await Effect.runPromise(Deferred.await(blocked))
+
+		await Effect.runPromise(Fiber.interrupt(fiber))
+
+		expect(events).toEqual(["applied", "rollback started", "rollback finished"])
+		expect(
+			await Bun.file(join(root, ".agency-graph-mutation.lock")).exists(),
+		).toBe(false)
+	})
 })