@markjaquith/agency 2.0.0 → 2.1.0

package/README.md

@@ -11,6 +11,7 @@ or write.
 - Git
 - [GitHub CLI](https://cli.github.com/) for `agency pr create`
 - OpenCode or Claude Code for `agency work`
+- [fzf](https://github.com/junegunn/fzf) for interactive work target selection
 
 ## Installation
 
@@ -310,13 +311,19 @@ agency phase show <task-id> <phase-id> [--json]
 ### Work and Pull Requests
 
 ```text
-agency work <task-id> [phase-id] [--opencode | --claude]
+agency work [<task-id> [phase-id] | --epic <epic-id>] [--opencode | --claude]
 agency pr create <task-id> [phase-id] [--draft] [--json]
 ```
 
-`agency work` fetches repositories, creates or reuses worktrees under `code/`,
-and launches an agent in the writable checkout with absolute task and phase
-context paths.
+`agency work` infers an epic, task, or phase from the current directory. From
+elsewhere in the workbase, it presents the full hierarchy in `fzf`. If `fzf` is
+not installed, Agency prints the hierarchy and asks for an explicit target.
+
+Epic and multi-phase task targets launch orchestration agents beside their
+documents. Single-phase tasks and phases fetch repositories, create or reuse
+worktrees under `code/`, and launch an execution agent in the writable checkout
+with absolute context paths. Explicit task, phase, and `--epic` targets override
+current-directory inference.
 
 Each writable `(repo, branch)` pair may belong to only one task or phase. Agency
 validation reports duplicate ownership, and `agency work` checks Git's worktree

package/cli.ts

@@ -206,6 +206,7 @@ const commands: Record<string, Command> = {
 				work({
 					taskId: args[0],
 					phaseId: args[1],
+					epicId: options.epic,
 					silent: options.silent,
 					verbose: options.verbose,
 					opencode: options.opencode,
@@ -257,7 +258,7 @@ Commands:
   epic <subcommand>      Manage epics
   phase <subcommand>     Manage task phases
   task <subcommand>      Manage tasks
-  work <task> [phase]    Materialize worktrees and launch an agent
+  work [task] [phase]    Work on an epic, task, or phase
   pr create              Create a pull request for an execution unit
   repo <subcommand>      Manage workbase repositories
   status                 Show status for the current workbase

package/package.json

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

package/skills/agency/SKILL.md

@@ -7,7 +7,7 @@ description: >
   coordinate work across repositories; materialize task worktrees; or create a
   PR through Agency.
 license: MIT
-compatibility: Requires the agency CLI, Git, and optionally gh plus OpenCode or Claude Code.
+compatibility: Requires the agency CLI and Git, plus OpenCode or Claude Code. Interactive work selection uses fzf; PR creation uses gh.
 ---
 
 # Agency
@@ -210,12 +210,20 @@ duplicate writable branch ownership, unknown dependencies, and dependency cycles
 ## Worktrees And Agent Launch
 
 ```bash
+agency work
 agency work <task-id> [phase-id]
+agency work --epic <epic-id>
 ```
 
 Use `--opencode` or `--claude` to require a specific agent. This command fetches
-repositories, creates or reuses the execution worktrees, changes into the
-writable checkout, and replaces the current process with the selected agent.
+repositories for execution targets, creates or reuses their worktrees, and
+replaces the current process with the selected agent. It infers the nearest
+epic, task, or phase from the current directory; otherwise it opens an `fzf`
+picker containing the workbase hierarchy.
+
+Epic and multi-phase task targets are orchestration sessions launched beside
+their documents. Single-phase tasks and phases are execution sessions launched
+in their writable checkout.
 
 The workbase may delegate writable checkout creation through
 `worktreeCreateCommand` in `agency.json`. Do not bypass that command or create a

package/src/cli.test.ts

@@ -43,7 +43,7 @@ describe("CLI", () => {
 		const version = await runCli(["--version"])
 		expect(version).toEqual({
 			exitCode: 0,
-			stdout: "v2.0.0\n",
+			stdout: "v0.0.0-development\n",
 			stderr: "",
 		})
 

package/src/commands/work.test.ts

@@ -1,9 +1,14 @@
 import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { FileSystemService } from "../services/FileSystemService"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { EpicService } from "../services/EpicService"
+import { TaskService } from "../services/TaskService"
+import { PhaseService } from "../services/PhaseService"
 import { WorktreeService } from "../services/WorktreeService"
 import { captureLogs } from "../test-utils"
 import { work } from "./work"
+import type { PickWorkTarget } from "../workbase/work-target"
 
 type ExecutionWorkspace = Effect.Effect.Success<
 	ReturnType<WorktreeService["materialize"]>
@@ -32,7 +37,11 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
 	readonly materializeError?: Error
-	readonly available?: Partial<Record<"opencode" | "claude", boolean>>
+	readonly available?: Partial<Record<"opencode" | "claude" | "fzf", boolean>>
+	readonly multiPhaseTasks?: readonly string[]
+	readonly epicRecords?: readonly any[]
+	readonly taskRecords?: readonly any[]
+	readonly phaseRecords?: readonly any[]
 }
 
 const createHarness = (options: HarnessOptions = {}) => {
@@ -51,6 +60,39 @@ const createHarness = (options: HarnessOptions = {}) => {
 				: Effect.succeed(options.workspace ?? singlePhaseWorkspace)
 		},
 	}
+	const workbase = {
+		discover: () => Effect.succeed("/workbase"),
+	}
+	const epics = {
+		show: (id: string) =>
+			Effect.succeed({
+				id,
+				path: `/workbase/epics/${id}/EPIC.md`,
+				data: { tasks: [] },
+			}),
+		list: () => Effect.succeed(options.epicRecords ?? []),
+	}
+	const tasks = {
+		show: (id: string) =>
+			Effect.succeed({
+				id,
+				path: `/workbase/tasks/${id}/TASK.md`,
+				data: options.multiPhaseTasks?.includes(id)
+					? { phases: [] }
+					: { repo: "agency", branch: `task/${id}`, base: "main" },
+			}),
+		list: () => Effect.succeed(options.taskRecords ?? []),
+	}
+	const phases = {
+		show: (taskId: string, id: string) =>
+			Effect.succeed({
+				taskId,
+				id,
+				path: `/workbase/tasks/${taskId}/phases/${id}/PHASE.md`,
+				data: { repo: "agency", branch: `task/${id}`, base: "main" },
+			}),
+		list: () => Effect.succeed(options.phaseRecords ?? []),
+	}
 	const fs = {
 		runCommand: (args: readonly string[]) => {
 			const cli = args[1] as "opencode" | "claude"
@@ -67,11 +109,19 @@ const createHarness = (options: HarnessOptions = {}) => {
 		events.push(`launch:${cli}`)
 		launches.push({ cli, args, cwd })
 	}
-	const run = (commandOptions: Parameters<typeof work>[0]) =>
+	const defaultPick: PickWorkTarget = () => Effect.succeed(null)
+	const run = (
+		commandOptions: Parameters<typeof work>[0],
+		pick: PickWorkTarget = defaultPick,
+	) =>
 		Effect.runPromise(
-			work(commandOptions, launch).pipe(
+			work(commandOptions, launch, pick).pipe(
 				Effect.provideService(WorktreeService, worktrees as never),
 				Effect.provideService(FileSystemService, fs as never),
+				Effect.provideService(WorkbaseService, workbase as never),
+				Effect.provideService(EpicService, epics as never),
+				Effect.provideService(TaskService, tasks as never),
+				Effect.provideService(PhaseService, phases as never),
 			) as Effect.Effect<void, unknown, never>,
 		)
 
@@ -79,11 +129,126 @@ const createHarness = (options: HarnessOptions = {}) => {
 }
 
 describe("work command", () => {
-	test("requires a task ID before materialization", async () => {
+	test("launches an epic agent from an epic directory", async () => {
 		const harness = createHarness()
 
-		await expect(harness.run({})).rejects.toThrow("Task ID is required")
-		expect(harness.events).toEqual([])
+		await harness.run({ cwd: "/workbase/epics/delivery", opencode: true })
+
+		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode",
+			args: [
+				"opencode",
+				"--prompt",
+				"Work on the epic. Read /workbase/epics/delivery/EPIC.md.",
+			],
+			cwd: "/workbase/epics/delivery",
+		})
+	})
+
+	test("launches a multi-phase task agent without materializing", async () => {
+		const harness = createHarness({ multiPhaseTasks: ["delivery"] })
+
+		await harness.run({ cwd: "/workbase/tasks/delivery", opencode: true })
+
+		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode",
+			args: [
+				"opencode",
+				"--prompt",
+				"Work on the task. Read /workbase/tasks/delivery/TASK.md.",
+			],
+			cwd: "/workbase/tasks/delivery",
+		})
+	})
+
+	test("infers a phase from a nested checkout directory", async () => {
+		const harness = createHarness({ workspace: multiPhaseWorkspace })
+
+		await harness.run({
+			cwd: "/workbase/tasks/example/phases/implementation/code/agency/src",
+			opencode: true,
+		})
+
+		expect(harness.events).toEqual([
+			"materialize",
+			"probe:opencode",
+			"launch:opencode",
+		])
+		expect(harness.launches[0]?.args).toContain(
+			"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
+		)
+	})
+
+	test("infers a single-phase task from a nested checkout directory", async () => {
+		const harness = createHarness()
+
+		await harness.run({
+			cwd: "/workbase/tasks/example/code/agency/src",
+			opencode: true,
+		})
+
+		expect(harness.events[0]).toBe("materialize")
+		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example/code/agency")
+	})
+
+	test("selects a target with fzf outside an entity directory", async () => {
+		const phase = {
+			taskId: "delivery",
+			id: "build",
+			path: "/workbase/tasks/delivery/phases/build/PHASE.md",
+			data: {},
+		}
+		const harness = createHarness({
+			workspace: multiPhaseWorkspace,
+			taskRecords: [
+				{
+					id: "delivery",
+					path: "/workbase/tasks/delivery/TASK.md",
+					data: { phases: [{ id: "build" }] },
+				},
+			],
+			phaseRecords: [phase],
+		})
+		const pick: PickWorkTarget = (choices) =>
+			Effect.succeed(
+				choices.find((choice) => choice.label.includes("build"))!.target,
+			)
+
+		await harness.run({ cwd: "/workbase", opencode: true }, pick)
+
+		expect(harness.events).toEqual([
+			"probe:fzf",
+			"materialize",
+			"probe:opencode",
+			"launch:opencode",
+		])
+		expect(harness.launches[0]?.cwd).toBe(
+			"/workbase/tasks/example/phases/implementation/code/agency",
+		)
+	})
+
+	test("prints the target tree when fzf is unavailable", async () => {
+		const harness = createHarness({
+			available: { fzf: false },
+			epicRecords: [
+				{
+					id: "delivery",
+					path: "/workbase/epics/delivery/EPIC.md",
+					data: { tasks: [] },
+				},
+			],
+		})
+
+		const logs = await captureLogs(async () => {
+			await expect(harness.run({ cwd: "/workbase" })).rejects.toThrow(
+				"fzf is required",
+			)
+		})
+
+		expect(logs).toEqual(["epic  delivery"])
+		expect(harness.launches).toEqual([])
 	})
 
 	test("rejects conflicting agent flags before materialization", async () => {
@@ -95,6 +260,15 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
+	test("rejects combining explicit epic and task targets", async () => {
+		const harness = createHarness()
+
+		await expect(
+			harness.run({ epicId: "delivery", taskId: "example" }),
+		).rejects.toThrow("Cannot combine --epic")
+		expect(harness.events).toEqual([])
+	})
+
 	test("launches OpenCode in the writable checkout with the single-phase prompt", async () => {
 		const harness = createHarness()
 

package/src/commands/work.ts

@@ -1,13 +1,25 @@
 import { Effect } from "effect"
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path"
 import type { BaseCommandOptions } from "../utils/command"
 import { WorktreeService } from "../services/WorktreeService"
 import { FileSystemService } from "../services/FileSystemService"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { EpicService } from "../services/EpicService"
+import { TaskService } from "../services/TaskService"
+import { PhaseService } from "../services/PhaseService"
 import { createLoggers } from "../utils/effect"
 import { execvp } from "../utils/exec"
+import {
+	buildWorkTargetChoices,
+	pickWorkTarget,
+	type PickWorkTarget,
+	type WorkTarget,
+} from "../workbase/work-target"
 
 interface WorkOptions extends BaseCommandOptions {
 	readonly taskId?: string
 	readonly phaseId?: string
+	readonly epicId?: string
 	readonly opencode?: boolean
 	readonly claude?: boolean
 }
@@ -22,28 +34,133 @@ const launchAgent: LaunchAgent = (cli, args, cwd) => {
 export const work = (
 	options: WorkOptions = {},
 	launch: LaunchAgent = launchAgent,
+	pick: PickWorkTarget = pickWorkTarget,
 ) =>
 	Effect.gen(function* () {
-		if (!options.taskId) {
-			return yield* Effect.fail(new Error("Task ID is required"))
-		}
 		if (options.opencode && options.claude) {
 			return yield* Effect.fail(
 				new Error("Cannot use both --opencode and --claude"),
 			)
 		}
+		if (options.epicId && (options.taskId || options.phaseId)) {
+			return yield* Effect.fail(
+				new Error("Cannot combine --epic with a task or phase ID"),
+			)
+		}
 
 		const worktrees = yield* WorktreeService
 		const fs = yield* FileSystemService
-		const { verboseLog } = createLoggers(options)
-		const workspace = yield* worktrees.materialize(
-			options.taskId,
-			options.phaseId,
-			options.cwd ?? process.cwd(),
-		)
-		const prompt = workspace.phasePath
-			? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
-			: `Start the task. Read ${workspace.taskPath}.`
+		const workbase = yield* WorkbaseService
+		const epics = yield* EpicService
+		const tasks = yield* TaskService
+		const phases = yield* PhaseService
+		const { log, verboseLog } = createLoggers(options)
+		const cwd = options.cwd ?? process.cwd()
+		const root = yield* workbase.discover(cwd)
+
+		let target: WorkTarget | null = null
+		if (options.epicId) {
+			const epic = yield* epics.show(options.epicId, root)
+			target = { kind: "epic", epicId: epic.id, path: epic.path }
+		} else if (options.taskId) {
+			const task = yield* tasks.show(options.taskId, root)
+			if (options.phaseId) {
+				const phase = yield* phases.show(task.id, options.phaseId, root)
+				target = {
+					kind: "phase",
+					taskId: task.id,
+					phaseId: phase.id,
+					path: phase.path,
+				}
+			} else {
+				target = {
+					kind: "task",
+					taskId: task.id,
+					path: task.path,
+					multiPhase: "phases" in task.data,
+				}
+			}
+		} else {
+			const path = relative(root, resolve(cwd))
+			const parts =
+				!path || isAbsolute(path) || path.startsWith(`..${sep}`)
+					? []
+					: path.split(sep)
+			if (parts[0] === "epics" && parts[1]) {
+				const epic = yield* epics.show(parts[1], root)
+				target = { kind: "epic", epicId: epic.id, path: epic.path }
+			} else if (parts[0] === "tasks" && parts[1]) {
+				const task = yield* tasks.show(parts[1], root)
+				if (parts[2] === "phases" && parts[3]) {
+					const phase = yield* phases.show(task.id, parts[3], root)
+					target = {
+						kind: "phase",
+						taskId: task.id,
+						phaseId: phase.id,
+						path: phase.path,
+					}
+				} else {
+					target = {
+						kind: "task",
+						taskId: task.id,
+						path: task.path,
+						multiPhase: "phases" in task.data,
+					}
+				}
+			}
+		}
+
+		if (!target) {
+			const epicRecords = yield* epics.list(root)
+			const taskRecords = yield* tasks.list(root)
+			const phaseRecords = []
+			for (const task of taskRecords) {
+				if ("phases" in task.data) {
+					phaseRecords.push(...(yield* phases.list(task.id, root)))
+				}
+			}
+			const choices = buildWorkTargetChoices(
+				epicRecords,
+				taskRecords,
+				phaseRecords,
+			)
+			if (choices.length === 0) {
+				return yield* Effect.fail(
+					new Error("No epics, tasks, or phases found in this workbase"),
+				)
+			}
+			const fzf = yield* fs.runCommand(["which", "fzf"], {
+				captureOutput: true,
+			})
+			if (fzf.exitCode !== 0) {
+				for (const choice of choices) log(choice.label)
+				return yield* Effect.fail(
+					new Error(
+						"fzf is required to select a work target; install fzf or provide a target explicitly",
+					),
+				)
+			}
+			target = yield* pick(choices)
+			if (!target) return
+		}
+
+		let prompt: string
+		let launchPath: string
+		if (target.kind === "epic") {
+			prompt = `Work on the epic. Read ${target.path}.`
+			launchPath = dirname(target.path)
+		} else if (target.kind === "task" && target.multiPhase) {
+			prompt = `Work on the task. Read ${target.path}.`
+			launchPath = dirname(target.path)
+		} else {
+			const taskId = target.taskId
+			const phaseId = target.kind === "phase" ? target.phaseId : undefined
+			const workspace = yield* worktrees.materialize(taskId, phaseId, root)
+			prompt = workspace.phasePath
+				? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
+				: `Start the task. Read ${workspace.taskPath}.`
+			launchPath = workspace.writablePath
+		}
 
 		const requested = options.claude ? "claude" : "opencode"
 		let cli = requested
@@ -58,17 +175,19 @@ export const work = (
 			return yield* Effect.fail(new Error(`${cli} CLI tool not found`))
 		}
 
-		verboseLog(`Launching ${cli} in ${workspace.writablePath}`)
+		verboseLog(`Launching ${cli} in ${launchPath}`)
 		const args = cli === "opencode" ? ["--prompt", prompt] : [prompt]
-		launch(cli, [cli, ...args], workspace.writablePath)
+		launch(cli, [cli, ...args], launchPath)
 	})
 
 export const help = `
-Usage: agency work <task-id> [phase-id]
+Usage: agency work [<task-id> [phase-id] | --epic <epic-id>]
 
-Materialize repository worktrees and launch an agent in the writable checkout.
+Launch an agent for the current epic, task, or phase. Outside an entity
+directory, select one with fzf.
 
 Options:
+  --epic <id>         Work on an epic
   --opencode           Require OpenCode
   --claude             Require Claude Code
 `

package/src/workbase/work-target.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test"
+import { buildWorkTargetChoices } from "./work-target"
+
+describe("work target choices", () => {
+	test("builds an ordered hierarchy with standalone tasks", () => {
+		const choices = buildWorkTargetChoices(
+			[
+				{
+					id: "delivery",
+					path: "/workbase/epics/delivery/EPIC.md",
+					data: {
+						description: "Ship the release",
+						tasks: [{ id: "multi" }, { id: "single" }],
+					},
+				},
+			],
+			[
+				{
+					id: "multi",
+					path: "/workbase/tasks/multi/TASK.md",
+					data: {
+						phases: [{ id: "build" }, { id: "verify" }],
+					},
+				},
+				{
+					id: "single",
+					path: "/workbase/tasks/single/TASK.md",
+					data: {},
+				},
+				{
+					id: "standalone",
+					path: "/workbase/tasks/standalone/TASK.md",
+					data: { description: "Independent work" },
+				},
+			],
+			[
+				{
+					taskId: "multi",
+					id: "verify",
+					path: "/workbase/tasks/multi/phases/verify/PHASE.md",
+					data: {},
+				},
+				{
+					taskId: "multi",
+					id: "build",
+					path: "/workbase/tasks/multi/phases/build/PHASE.md",
+					data: {},
+				},
+				{
+					taskId: "multi",
+					id: "unlisted",
+					path: "/workbase/tasks/multi/phases/unlisted/PHASE.md",
+					data: {},
+				},
+			],
+		)
+
+		expect(choices.map((choice) => choice.label)).toEqual([
+			"epic  delivery - Ship the release",
+			"  task  multi",
+			"    phase  build",
+			"    phase  verify",
+			"    phase  unlisted",
+			"  task  single",
+			"task  standalone - Independent work",
+		])
+		expect(choices.map((choice) => choice.target.kind)).toEqual([
+			"epic",
+			"task",
+			"phase",
+			"phase",
+			"phase",
+			"task",
+			"task",
+		])
+	})
+})

package/src/workbase/work-target.ts

@@ -0,0 +1,180 @@
+import { Effect } from "effect"
+
+export type WorkTarget =
+	| {
+			readonly kind: "epic"
+			readonly epicId: string
+			readonly path: string
+	  }
+	| {
+			readonly kind: "task"
+			readonly taskId: string
+			readonly path: string
+			readonly multiPhase: boolean
+	  }
+	| {
+			readonly kind: "phase"
+			readonly taskId: string
+			readonly phaseId: string
+			readonly path: string
+	  }
+
+interface EpicRecord {
+	readonly id: string
+	readonly path: string
+	readonly data: {
+		readonly description?: string
+		readonly tasks: readonly { readonly id: string }[]
+	}
+}
+
+interface TaskRecord {
+	readonly id: string
+	readonly path: string
+	readonly data:
+		| {
+				readonly description?: string
+				readonly phases: readonly { readonly id: string }[]
+		  }
+		| { readonly description?: string }
+}
+
+interface PhaseRecord {
+	readonly taskId: string
+	readonly id: string
+	readonly path: string
+	readonly data: { readonly description?: string }
+}
+
+export interface WorkTargetChoice {
+	readonly label: string
+	readonly target: WorkTarget
+}
+
+const label = (
+	indent: string,
+	kind: WorkTarget["kind"],
+	id: string,
+	description?: string,
+) =>
+	`${indent}${kind}  ${id}${description === undefined ? "" : ` - ${description}`}`
+
+const taskChoices = (
+	task: TaskRecord,
+	phaseRecords: readonly PhaseRecord[],
+	indent: string,
+): readonly WorkTargetChoice[] => {
+	const multiPhase = "phases" in task.data
+	const choices: WorkTargetChoice[] = [
+		{
+			label: label(indent, "task", task.id, task.data.description),
+			target: {
+				kind: "task",
+				taskId: task.id,
+				path: task.path,
+				multiPhase,
+			},
+		},
+	]
+	if (!multiPhase) return choices
+
+	const phases = new Map(phaseRecords.map((phase) => [phase.id, phase]))
+	const renderedPhases = new Set<string>()
+	for (const phase of task.data.phases) {
+		const record = phases.get(phase.id)
+		if (!record) continue
+		renderedPhases.add(record.id)
+		choices.push({
+			label: label(`${indent}  `, "phase", record.id, record.data.description),
+			target: {
+				kind: "phase",
+				taskId: task.id,
+				phaseId: record.id,
+				path: record.path,
+			},
+		})
+	}
+	for (const record of phaseRecords) {
+		if (renderedPhases.has(record.id)) continue
+		choices.push({
+			label: label(`${indent}  `, "phase", record.id, record.data.description),
+			target: {
+				kind: "phase",
+				taskId: task.id,
+				phaseId: record.id,
+				path: record.path,
+			},
+		})
+	}
+	return choices
+}
+
+export const buildWorkTargetChoices = (
+	epicRecords: readonly EpicRecord[],
+	taskRecords: readonly TaskRecord[],
+	phaseRecords: readonly PhaseRecord[],
+): readonly WorkTargetChoice[] => {
+	const choices: WorkTargetChoice[] = []
+	const tasks = new Map(taskRecords.map((task) => [task.id, task]))
+	const phases = new Map<string, PhaseRecord[]>()
+	for (const phase of phaseRecords) {
+		const records = phases.get(phase.taskId) ?? []
+		records.push(phase)
+		phases.set(phase.taskId, records)
+	}
+	const nestedTasks = new Set<string>()
+
+	for (const epic of epicRecords) {
+		choices.push({
+			label: label("", "epic", epic.id, epic.data.description),
+			target: { kind: "epic", epicId: epic.id, path: epic.path },
+		})
+		for (const child of epic.data.tasks) {
+			const task = tasks.get(child.id)
+			if (!task || nestedTasks.has(task.id)) continue
+			nestedTasks.add(task.id)
+			choices.push(...taskChoices(task, phases.get(task.id) ?? [], "  "))
+		}
+	}
+
+	for (const task of taskRecords) {
+		if (nestedTasks.has(task.id)) continue
+		choices.push(...taskChoices(task, phases.get(task.id) ?? [], ""))
+	}
+
+	return choices
+}
+
+export type PickWorkTarget = (
+	choices: readonly WorkTargetChoice[],
+) => Effect.Effect<WorkTarget | null, Error>
+
+const parseWorkTargetSelection = (
+	output: string,
+	choices: readonly WorkTargetChoice[],
+) => {
+	const index = Number.parseInt(output.split("\t", 1)[0] ?? "", 10)
+	return choices[index]?.target ?? null
+}
+
+export const pickWorkTarget: PickWorkTarget = (choices) =>
+	Effect.tryPromise({
+		try: async () => {
+			const input = choices
+				.map((choice, index) => `${index}\t${choice.label}`)
+				.join("\n")
+			const process = Bun.spawn(
+				["fzf", "--delimiter=\t", "--with-nth=2..", "--prompt=Work on> "],
+				{ stdin: new Blob([input]), stdout: "pipe", stderr: "inherit" },
+			)
+			const [exitCode, output] = await Promise.all([
+				process.exited,
+				new Response(process.stdout).text(),
+			])
+			if (exitCode === 1 || exitCode === 130) return null
+			if (exitCode !== 0) throw new Error(`fzf exited with code ${exitCode}`)
+			return parseWorkTargetSelection(output, choices)
+		},
+		catch: (cause) =>
+			new Error("Failed to select a work target with fzf", { cause }),
+	})