@markjaquith/agency 3.2.8 → 3.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "3.2.8",
+  "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/FileSystemService.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "../test-utils"
+import { FileSystemService } from "./FileSystemService"
+
+const runFileSystem = <A, E>(effect: Effect.Effect<A, E, FileSystemService>) =>
+	Effect.runPromise(effect.pipe(Effect.provide(FileSystemService.Default)))
+
+describe("FileSystemService", () => {
+	const roots: string[] = []
+
+	afterEach(async () => {
+		await Promise.all(roots.splice(0).map(cleanupTempDir))
+	})
+
+	test("distinguishes missing files from other read failures", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		const directory = join(root, "document")
+		await mkdir(directory)
+
+		const missing = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) => service.readFile(join(root, "missing"))),
+				Effect.either,
+			),
+		)
+		expect(missing).toMatchObject({
+			_tag: "Left",
+			left: { _tag: "FileNotFoundError" },
+		})
+
+		const unreadable = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) => service.readFile(directory)),
+				Effect.either,
+			),
+		)
+		expect(unreadable).toMatchObject({
+			_tag: "Left",
+			left: {
+				_tag: "FileSystemError",
+				message: `Failed to read file: ${directory}`,
+			},
+		})
+	})
+
+	test("only treats a missing symlink path as absent", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		const regularFile = join(root, "regular")
+		await Bun.write(regularFile, "content")
+
+		await expect(
+			runFileSystem(
+				FileSystemService.pipe(
+					Effect.flatMap((service) =>
+						service.readSymlinkTarget(join(root, "missing")),
+					),
+				),
+			),
+		).resolves.toBeNull()
+		const unreadable = await runFileSystem(
+			FileSystemService.pipe(
+				Effect.flatMap((service) =>
+					service.readSymlinkTarget(join(regularFile, "child")),
+				),
+				Effect.either,
+			),
+		)
+		expect(unreadable).toMatchObject({
+			_tag: "Left",
+			left: {
+				_tag: "FileSystemError",
+				message: `Failed to read symlink target: ${join(regularFile, "child")}`,
+			},
+		})
+	})
+})

package/src/services/FileSystemService.ts

@@ -23,6 +23,12 @@ class FileNotFoundError extends Data.TaggedError("FileNotFoundError")<{
 	path: string
 }> {}
 
+const isFileNotFound = (error: unknown) =>
+	typeof error === "object" &&
+	error !== null &&
+	"code" in error &&
+	error.code === "ENOENT"
+
 // FileSystem Service using Effect.Service pattern
 export class FileSystemService extends Effect.Service<FileSystemService>()(
 	"FileSystemService",
@@ -88,7 +94,13 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 			readFile: (path: string) =>
 				Effect.tryPromise({
 					try: () => Bun.file(path).text(),
-					catch: () => new FileNotFoundError({ path }),
+					catch: (error) =>
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read file: ${path}`,
+									cause: error,
+								}),
 				}),
 
 			inspectFile: (path: string) =>
@@ -184,10 +196,12 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 						}))
 					},
 					catch: (error) =>
-						new FileSystemError({
-							message: `Failed to read directory: ${path}`,
-							cause: error,
-						}),
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read directory: ${path}`,
+									cause: error,
+								}),
 				}),
 
 			deleteDirectory: (path: string) =>
@@ -301,8 +315,16 @@ export class FileSystemService extends Effect.Service<FileSystemService>()(
 						}
 						return await readlink(path)
 					},
-					catch: () => null,
-				}).pipe(Effect.catchAll(() => Effect.succeed(null))),
+					catch: (error) =>
+						isFileNotFound(error)
+							? new FileNotFoundError({ path })
+							: new FileSystemError({
+									message: `Failed to read symlink target: ${path}`,
+									cause: error,
+								}),
+				}).pipe(
+					Effect.catchTag("FileNotFoundError", () => Effect.succeed(null)),
+				),
 		}),
 	},
 ) {}

package/src/services/GraphService.test.ts

@@ -230,6 +230,17 @@ describe("GraphService", () => {
 		expect(calls).toBe(0)
 	})
 
+	test("propagates directory discovery failures", async () => {
+		const root = await createTempDir()
+		roots.push(root)
+		await write(root, "agency.json", '{"version":2}\n')
+		await write(root, "tasks", "not a directory")
+
+		await expect(getGraph(root)).rejects.toThrow(
+			`Failed to read directory: ${join(root, "tasks")}`,
+		)
+	})
+
 	test("never reports active or terminal execution units as ready", async () => {
 		const root = await createWorkbase()
 		roots.push(root)

package/src/services/GraphService.ts

@@ -158,7 +158,7 @@ export class GraphService extends Effect.Service<GraphService>()(
 									.map((entry) => entry.name)
 									.sort(),
 							),
-							Effect.catchAll(() => Effect.succeed([])),
+							Effect.catchTag("FileNotFoundError", () => Effect.succeed([])),
 						)
 
 					const readDocument = <S extends Schema.Schema.AnyNoContext>(

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)
+	})
 })