@markjaquith/agency 2.14.0 → 2.15.0

package/README.md

@@ -11,7 +11,6 @@ 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
 
@@ -146,6 +145,29 @@ The configured command applies only to the writable checkout. Supplemental
 read-only repositories remain detached Git worktrees at their declared refs so
 they do not acquire writable branches.
 
+### Custom Chooser Command
+
+Interactive selection uses a native numbered chooser by default. To use an
+external chooser, configure an argv command in `agency.json`:
+
+```json
+{
+	"version": 2,
+	"chooserCommand": ["fzf", "--ansi", "--delimiter=\\t", "--with-nth=2.."]
+}
+```
+
+Agency writes one `key<TAB>label` record per choice to the command's stdin. The
+command must write the selected opaque key or selected record to stdout; commands
+such as `["gum", "filter"]` therefore work without wrappers. Exit codes 1 and
+130, empty stdout, native `q`, and an empty native response cancel selection.
+Other nonzero exits, unknown keys, and invalid native numbers are errors.
+
+Selectors are opened only when stdin and stderr are terminals and neither
+`--no-input` nor JSON output is active. Labels use color only when stderr is a
+terminal, `TERM` is not `dumb`, and `NO_COLOR` is unset; otherwise selectors use
+plain labels without ANSI styling or icon-font dependencies.
+
 ## Frontmatter
 
 ### Epic

package/package.json

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

package/src/commands/task.ts

@@ -6,6 +6,8 @@ import { EpicService } from "../services/EpicService"
 import { RepositoryService } from "../services/RepositoryService"
 import { createLoggers } from "../utils/effect"
 import { parseRepositoryReferences } from "../workbase/repository-reference"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { choose } from "../utils/chooser"
 
 interface TaskOptions extends BaseCommandOptions {
 	readonly subcommand?: string
@@ -29,7 +31,9 @@ export interface TaskInteraction {
 	) => Effect.Effect<string | null, Error>
 }
 
-const defaultInteraction: TaskInteraction = {
+const defaultInteraction = (
+	chooserCommand?: readonly string[],
+): TaskInteraction => ({
 	text: (prompt) =>
 		Effect.tryPromise({
 			try: async () => {
@@ -46,37 +50,23 @@ const defaultInteraction: TaskInteraction = {
 			catch: (cause) => new Error("Failed to read task input", { cause }),
 		}),
 	select: (prompt, choices) =>
-		Effect.tryPromise({
-			try: async () => {
-				const process = Bun.spawn(
-					["fzf", `--prompt=${prompt}> `, "--height=~40%", "--reverse"],
-					{
-						stdin: new Blob([choices.join("\n")]),
-						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 output.trim() || null
-			},
-			catch: (cause) =>
-				new Error("Failed to select task input with fzf", { cause }),
-		}),
-}
+		choose(
+			prompt,
+			choices.map((choice, index) => ({
+				key: String(index),
+				label: choice,
+				value: choice,
+			})),
+			chooserCommand,
+		),
+})
 
-export const task = (
-	options: TaskOptions,
-	interaction: TaskInteraction = defaultInteraction,
-) =>
+export const task = (options: TaskOptions, interaction?: TaskInteraction) =>
 	Effect.gen(function* () {
 		const tasks = yield* TaskService
 		const epics = yield* EpicService
 		const repositories = yield* RepositoryService
+		const workbase = yield* WorkbaseService
 		const { log } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
 
@@ -89,8 +79,13 @@ export const task = (
 						),
 					)
 				}
+				const activeInteraction =
+					interaction ??
+					defaultInteraction(
+						(yield* workbase.loadConfig(cwd)).config.chooserCommand,
+					)
 				const id =
-					options.args[0] ?? (yield* interaction.text("Task ID: ")).trim()
+					options.args[0] ?? (yield* activeInteraction.text("Task ID: ")).trim()
 				if (!id) {
 					return yield* Effect.fail(new Error("Task ID is required"))
 				}
@@ -103,18 +98,20 @@ export const task = (
 
 				if (options.ticketUrl === undefined) {
 					ticketUrl =
-						(yield* interaction.text("Ticket URL (optional): ")).trim() || null
+						(yield* activeInteraction.text("Ticket URL (optional): ")).trim() ||
+						null
 				}
 				if (options.description === undefined) {
 					description =
-						(yield* interaction.text("Description (optional): ")).trim() ||
-						undefined
+						(yield* activeInteraction.text(
+							"Description (optional): ",
+						)).trim() || undefined
 				}
 				if (options.epic === undefined) {
 					const epicRecords = yield* epics.list(cwd)
 					if (epicRecords.length > 0) {
 						const none = "(none)"
-						const selected = yield* interaction.select("Parent epic", [
+						const selected = yield* activeInteraction.select("Parent epic", [
 							none,
 							...epicRecords.map((record) => record.id),
 						])
@@ -125,7 +122,7 @@ export const task = (
 					}
 				}
 				if (options.multiPhase === undefined) {
-					const selected = yield* interaction.select("Task type", [
+					const selected = yield* activeInteraction.select("Task type", [
 						"single-phase",
 						"multi-phase",
 					])
@@ -144,7 +141,7 @@ export const task = (
 							),
 						)
 					}
-					const selected = yield* interaction.select(
+					const selected = yield* activeInteraction.select(
 						"Writable repository",
 						records.map((record) => record.alias),
 					)

package/src/commands/validate.ts

@@ -32,12 +32,7 @@ export const validate = (
 		const startPath = options.path ?? options.cwd ?? process.cwd()
 		const root = options.path
 			? yield* workbase.discover(startPath)
-			: yield* resolveWorkbase(
-					startPath,
-					log,
-					pick,
-					options.inputAllowed ?? true,
-				)
+			: yield* resolveWorkbase(startPath, pick, options.inputAllowed ?? true)
 		if (!root) return
 		const report = yield* workbase.validate(root)
 

package/src/commands/work.test.ts

@@ -46,7 +46,8 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
 	readonly materializeError?: Error
-	readonly available?: Partial<Record<"opencode" | "claude" | "fzf", boolean>>
+	readonly available?: Partial<Record<"opencode" | "claude", boolean>>
+	readonly chooserCommand?: readonly string[]
 	readonly multiPhaseTasks?: readonly string[]
 	readonly epicRecords?: readonly any[]
 	readonly taskRecords?: readonly any[]
@@ -93,6 +94,14 @@ const createHarness = (options: HarnessOptions = {}) => {
 					})
 				: Effect.succeed("/workbase"),
 		listRegistered: () => Effect.succeed(options.registeredWorkbases ?? []),
+		loadConfig: () =>
+			Effect.succeed({
+				root: "/workbase",
+				config: {
+					version: 2 as const,
+					chooserCommand: options.chooserCommand,
+				},
+			}),
 	}
 	const epics = {
 		show: (id: string) =>
@@ -359,7 +368,7 @@ describe("work command", () => {
 		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
 	})
 
-	test("selects a target with fzf when no directory is provided", async () => {
+	test("selects a target when no directory is provided", async () => {
 		const phase = {
 			taskId: "delivery",
 			id: "build",
@@ -385,7 +394,6 @@ describe("work command", () => {
 		await harness.run({ cwd: "/workbase/tasks/example", opencode: true }, pick)
 
 		expect(harness.events).toEqual([
-			"probe:fzf",
 			"materialize",
 			"probe:opencode",
 			"launch:opencode",
@@ -442,7 +450,6 @@ describe("work command", () => {
 
 		expect(selections).toEqual([["/first", "/workbase"]])
 		expect(harness.events).toEqual([
-			"probe:fzf",
 			"materialize",
 			"probe:opencode",
 			"launch:opencode",
@@ -476,9 +483,9 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
-	test("prints the target tree when fzf is unavailable", async () => {
+	test("passes the configured chooser command to the shared picker", async () => {
 		const harness = createHarness({
-			available: { fzf: false },
+			chooserCommand: ["gum", "filter"],
 			epicRecords: [
 				{
 					id: "delivery",
@@ -487,14 +494,15 @@ describe("work command", () => {
 				},
 			],
 		})
+		let command: readonly string[] | undefined
+		const pick: PickWorkTarget = (_choices, chooserCommand) => {
+			command = chooserCommand
+			return Effect.succeed(null)
+		}
 
-		const logs = await captureLogs(async () => {
-			await expect(harness.run({ cwd: "/workbase" })).rejects.toThrow(
-				"fzf is required",
-			)
-		})
+		await harness.run({ cwd: "/workbase" }, pick)
 
-		expect(logs).toEqual(["\x1b[35m\x1b[0m delivery"])
+		expect(command).toEqual(["gum", "filter"])
 		expect(harness.launches).toEqual([])
 	})
 

package/src/commands/work.ts

@@ -89,7 +89,7 @@ export const work = (
 			: false
 		const startPath = isDirectory && directoryPath ? directoryPath : cwd
 		const inputAllowed = options.inputAllowed ?? true
-		const root = yield* resolveWorkbase(startPath, log, pickBase, inputAllowed)
+		const root = yield* resolveWorkbase(startPath, pickBase, inputAllowed)
 		if (!root) return
 
 		let target: WorkTarget | null = null
@@ -178,18 +178,8 @@ export const work = (
 					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 directory explicitly",
-					),
-				)
-			}
-			target = yield* pick(choices)
+			const { config } = yield* workbase.loadConfig(root)
+			target = yield* pick(choices, config.chooserCommand)
 			if (!target) return
 		}
 
@@ -332,7 +322,7 @@ Usage: agency work [<directory-or-task-id> | --epic <epic-id>]
        agency work prepare [target] [--dry-run] [--json]
 
 Launch an agent for an epic, task, or phase. With no directory, select one
-with fzf. A positional argument resolves as a directory first, then as a task
+interactively. A positional argument resolves as a directory first, then as a task
 ID. Use '.' for the current directory. Outside a workbase, select a registered
 workbase first.
 

package/src/utils/chooser.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { choose, type ChooserIO } from "./chooser"
+
+const choices = [
+	{ key: "first-key", label: "\x1b[32mFirst\x1b[0m", value: 1 },
+	{ key: "second key", label: "Second", value: 2 },
+]
+
+const createIO = (
+	overrides: Partial<ChooserIO> = {},
+): ChooserIO & { readonly writes: string[]; readonly inputs: string[] } => {
+	const writes: string[] = []
+	const inputs: string[] = []
+	return {
+		inputIsTTY: true,
+		outputIsTTY: true,
+		color: false,
+		write: (message) => writes.push(message),
+		question: async () => "1",
+		run: async (_command, input) => {
+			inputs.push(input)
+			return { exitCode: 0, stdout: "first-key\n" }
+		},
+		...overrides,
+		writes,
+		inputs,
+	}
+}
+
+describe("chooser", () => {
+	test("offers a plain-text numbered chooser on a TTY", async () => {
+		const io = createIO({ question: async () => "2" })
+
+		const result = await Effect.runPromise(
+			choose("Pick one", choices, undefined, io),
+		)
+
+		expect(result).toBe(2)
+		expect(io.writes.join("")).toBe("Pick one\n  1. First\n  2. Second\n")
+	})
+
+	test("preserves colors when enabled", async () => {
+		const io = createIO({ color: true })
+
+		await Effect.runPromise(choose("Pick one", choices, undefined, io))
+
+		expect(io.writes.join("")).toContain("\x1b[32mFirst\x1b[0m")
+	})
+
+	test("passes generic records to an external argv command", async () => {
+		const io = createIO()
+
+		const result = await Effect.runPromise(
+			choose("Pick one", choices, ["custom-chooser", "--flag"], io),
+		)
+
+		expect(result).toBe(1)
+		expect(io.inputs).toEqual(["first-key\tFirst\nsecond key\tSecond\n"])
+	})
+
+	test("accepts a selected record from fzf or gum", async () => {
+		const io = createIO({
+			run: async () => ({ exitCode: 0, stdout: "second key\tSecond\n" }),
+		})
+
+		expect(
+			await Effect.runPromise(choose("Pick", choices, ["gum", "filter"], io)),
+		).toBe(2)
+	})
+
+	test("treats native and external cancellation as no selection", async () => {
+		const native = createIO({ question: async () => "q" })
+		const external = createIO({
+			run: async () => ({ exitCode: 130, stdout: "" }),
+		})
+
+		expect(
+			await Effect.runPromise(choose("Pick", choices, undefined, native)),
+		).toBeNull()
+		expect(
+			await Effect.runPromise(choose("Pick", choices, ["chooser"], external)),
+		).toBeNull()
+	})
+
+	test("uses one typed error for unavailable input and invalid keys", async () => {
+		const nonTTY = createIO({ inputIsTTY: false })
+		const unknownKey = createIO({
+			run: async () => ({ exitCode: 0, stdout: "missing\n" }),
+		})
+
+		const unavailable = await Effect.runPromise(
+			Effect.flip(choose("Pick", choices, undefined, nonTTY)),
+		)
+		const invalid = await Effect.runPromise(
+			Effect.flip(choose("Pick", choices, ["chooser"], unknownKey)),
+		)
+
+		expect(unavailable).toMatchObject({
+			name: "ChooserError",
+			reason: "input-unavailable",
+		})
+		expect(invalid).toMatchObject({
+			name: "ChooserError",
+			reason: "invalid-selection",
+		})
+	})
+})

package/src/utils/chooser.ts

@@ -0,0 +1,222 @@
+import { Effect } from "effect"
+import { createInterface } from "node:readline/promises"
+
+export interface Choice<T> {
+	readonly key: string
+	readonly label: string
+	readonly plainLabel?: string
+	readonly value: T
+}
+
+export type ChooserErrorReason =
+	| "invalid-choices"
+	| "input-unavailable"
+	| "invalid-selection"
+	| "command-failed"
+
+export class ChooserError extends Error {
+	override readonly name = "ChooserError"
+
+	constructor(
+		readonly reason: ChooserErrorReason,
+		message: string,
+		options?: ErrorOptions,
+	) {
+		super(message, options)
+	}
+}
+
+interface ExternalResult {
+	readonly exitCode: number
+	readonly stdout: string
+}
+
+export interface ChooserIO {
+	readonly inputIsTTY: boolean
+	readonly outputIsTTY: boolean
+	readonly color: boolean
+	readonly write: (message: string) => void
+	readonly question: (prompt: string) => Promise<string>
+	readonly run: (
+		command: readonly string[],
+		input: string,
+	) => Promise<ExternalResult>
+}
+
+const stripAnsi = (value: string) =>
+	value.replace(
+		/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g,
+		"",
+	)
+
+const defaultIO = (): ChooserIO => ({
+	inputIsTTY: Boolean(process.stdin.isTTY),
+	outputIsTTY: Boolean(process.stderr.isTTY),
+	color:
+		Boolean(process.stderr.isTTY) &&
+		process.env.NO_COLOR === undefined &&
+		process.env.TERM !== "dumb",
+	write: (message) => process.stderr.write(message),
+	question: async (prompt) => {
+		const input = createInterface({
+			input: process.stdin,
+			output: process.stderr,
+		})
+		try {
+			return await input.question(prompt)
+		} finally {
+			input.close()
+		}
+	},
+	run: async (command, input) => {
+		const child = Bun.spawn([...command], {
+			stdin: new Blob([input]),
+			stdout: "pipe",
+			stderr: "inherit",
+		})
+		const [exitCode, stdout] = await Promise.all([
+			child.exited,
+			new Response(child.stdout).text(),
+		])
+		return { exitCode, stdout }
+	},
+})
+
+const displayLabel = (choice: Choice<unknown>, color: boolean) => {
+	const normalized = (
+		color ? choice.label : (choice.plainLabel ?? choice.label)
+	).replace(/[\r\n]+/g, " ")
+	return color ? normalized : stripAnsi(normalized)
+}
+
+const validateChoices = <T>(choices: readonly Choice<T>[]) => {
+	if (choices.length === 0) {
+		throw new ChooserError(
+			"invalid-choices",
+			"Cannot choose from an empty list",
+		)
+	}
+	const keys = new Set<string>()
+	for (const choice of choices) {
+		if (!choice.key || /[\t\r\n]/.test(choice.key)) {
+			throw new ChooserError(
+				"invalid-choices",
+				"Chooser keys must be non-empty and cannot contain tabs or newlines",
+			)
+		}
+		if (keys.has(choice.key)) {
+			throw new ChooserError(
+				"invalid-choices",
+				`Duplicate chooser key: ${choice.key}`,
+			)
+		}
+		keys.add(choice.key)
+	}
+}
+
+const selectedChoice = <T>(key: string, choices: readonly Choice<T>[]) => {
+	const selected = choices.find((choice) => choice.key === key)
+	if (!selected) {
+		throw new ChooserError(
+			"invalid-selection",
+			`Chooser returned an unknown key: ${key}`,
+		)
+	}
+	return selected.value
+}
+
+const externalChoice = async <T>(
+	choices: readonly Choice<T>[],
+	command: readonly string[],
+	io: ChooserIO,
+) => {
+	let result: ExternalResult
+	try {
+		const records = `${choices
+			.map((choice) => `${choice.key}\t${displayLabel(choice, io.color)}`)
+			.join("\n")}\n`
+		result = await io.run(command, records)
+	} catch (cause) {
+		throw new ChooserError(
+			"command-failed",
+			`Failed to run chooser command: ${command.join(" ")}`,
+			{ cause },
+		)
+	}
+	if (result.exitCode === 1 || result.exitCode === 130) return null
+	if (result.exitCode !== 0) {
+		throw new ChooserError(
+			"command-failed",
+			`Chooser command exited with code ${result.exitCode}`,
+		)
+	}
+	const output = result.stdout.replace(/\r?\n$/, "")
+	if (!output) return null
+	if (/[\r\n]/.test(output)) {
+		throw new ChooserError(
+			"invalid-selection",
+			"Chooser command returned more than one key",
+		)
+	}
+	const key = output.split("\t", 1)[0] ?? ""
+	return selectedChoice(key, choices)
+}
+
+const nativeChoice = async <T>(
+	choices: readonly Choice<T>[],
+	prompt: string,
+	io: ChooserIO,
+) => {
+	if (!io.inputIsTTY || !io.outputIsTTY) {
+		throw new ChooserError(
+			"input-unavailable",
+			"Interactive selection requires a terminal; provide an explicit value or use --no-input",
+		)
+	}
+	io.write(`${prompt}\n`)
+	for (const [index, choice] of choices.entries()) {
+		io.write(`  ${index + 1}. ${displayLabel(choice, io.color)}\n`)
+	}
+	let answer: string
+	try {
+		answer = (
+			await io.question(`Select [1-${choices.length}] (q to cancel): `)
+		).trim()
+	} catch (cause) {
+		if (cause instanceof Error && cause.name === "AbortError") return null
+		throw new ChooserError("input-unavailable", "Failed to read selection", {
+			cause,
+		})
+	}
+	if (!answer || answer.toLowerCase() === "q") return null
+	if (!/^\d+$/.test(answer)) {
+		throw new ChooserError("invalid-selection", `Invalid selection: ${answer}`)
+	}
+	const selected = choices[Number.parseInt(answer, 10) - 1]
+	if (!selected) {
+		throw new ChooserError(
+			"invalid-selection",
+			`Selection must be between 1 and ${choices.length}`,
+		)
+	}
+	return selected.value
+}
+
+export const choose = <T>(
+	prompt: string,
+	choices: readonly Choice<T>[],
+	command?: readonly string[],
+	io: ChooserIO = defaultIO(),
+): Effect.Effect<T | null, ChooserError> =>
+	Effect.tryPromise({
+		try: async () => {
+			validateChoices(choices)
+			return command
+				? await externalChoice(choices, command, io)
+				: await nativeChoice(choices, prompt, io)
+		},
+		catch: (cause) =>
+			cause instanceof ChooserError
+				? cause
+				: new ChooserError("input-unavailable", "Selection failed", { cause }),
+	})

package/src/workbase/schemas.test.ts

@@ -284,4 +284,16 @@ describe("schema boundaries", () => {
 			).not.toThrow()
 		}
 	})
+
+	test("accepts a configured chooser argv", () => {
+		expect(
+			Schema.decodeUnknownSync(WorkbaseConfig)({
+				version: 2,
+				chooserCommand: ["fzf", "--accept-nth=1"],
+			}),
+		).toEqual({
+			version: 2,
+			chooserCommand: ["fzf", "--accept-nth=1"],
+		})
+	})
 })

package/src/workbase/schemas.ts

@@ -50,6 +50,7 @@ const GitHubPullRequestUrl = NonEmptyString.pipe(
 
 export const WorkbaseConfig = Schema.Struct({
 	version: Schema.Literal(2),
+	chooserCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 	worktreeCreateCommand: Schema.optional(Schema.NonEmptyArray(NonEmptyString)),
 })
 

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

@@ -80,5 +80,15 @@ describe("work target choices", () => {
 			"task",
 			"task",
 		])
+		expect(choices.map((choice) => choice.plainLabel)).toEqual([
+			"epic delivery - Ship the release",
+			"  task multi",
+			"    [working] phase build",
+			"    [done] phase verify",
+			"    [dropped] phase unlisted",
+			"  [done] task single",
+			"[open] task standalone - Independent work",
+			"[delegated] task delegated",
+		])
 	})
 })

package/src/workbase/work-target.ts

@@ -1,5 +1,6 @@
 import { Effect } from "effect"
 import type { WorkStatus } from "./schemas"
+import { choose } from "../utils/chooser"
 
 export type WorkTarget =
 	| {
@@ -52,6 +53,7 @@ interface PhaseRecord {
 
 export interface WorkTargetChoice {
 	readonly label: string
+	readonly plainLabel: string
 	readonly target: WorkTarget
 }
 
@@ -78,6 +80,15 @@ const label = (
 		}[kind]
 	} ${id}${description === undefined ? "" : `\x1b[2m - ${description}\x1b[0m`}`
 
+const plainLabel = (
+	indent: string,
+	kind: WorkTarget["kind"],
+	id: string,
+	description?: string,
+	status?: WorkStatus,
+) =>
+	`${indent}${status === undefined ? "" : `[${status}] `}${kind} ${id}${description === undefined ? "" : ` - ${description}`}`
+
 const taskChoices = (
 	task: TaskRecord,
 	phaseRecords: readonly PhaseRecord[],
@@ -93,6 +104,13 @@ const taskChoices = (
 				task.data.description,
 				multiPhase ? undefined : (task.data.status ?? "open"),
 			),
+			plainLabel: plainLabel(
+				indent,
+				"task",
+				task.id,
+				task.data.description,
+				multiPhase ? undefined : (task.data.status ?? "open"),
+			),
 			target: {
 				kind: "task",
 				taskId: task.id,
@@ -117,6 +135,13 @@ const taskChoices = (
 				record.data.description,
 				record.data.status ?? "open",
 			),
+			plainLabel: plainLabel(
+				`${indent}  `,
+				"phase",
+				record.id,
+				record.data.description,
+				record.data.status ?? "open",
+			),
 			target: {
 				kind: "phase",
 				taskId: task.id,
@@ -135,6 +160,13 @@ const taskChoices = (
 				record.data.description,
 				record.data.status ?? "open",
 			),
+			plainLabel: plainLabel(
+				`${indent}  `,
+				"phase",
+				record.id,
+				record.data.description,
+				record.data.status ?? "open",
+			),
 			target: {
 				kind: "phase",
 				taskId: task.id,
@@ -164,6 +196,7 @@ export const buildWorkTargetChoices = (
 	for (const epic of epicRecords) {
 		choices.push({
 			label: label("", "epic", epic.id, epic.data.description),
+			plainLabel: plainLabel("", "epic", epic.id, epic.data.description),
 			target: { kind: "epic", epicId: epic.id, path: epic.path },
 		})
 		for (const child of epic.data.tasks) {
@@ -184,40 +217,17 @@ export const buildWorkTargetChoices = (
 
 export type PickWorkTarget = (
 	choices: readonly WorkTargetChoice[],
+	command?: readonly string[],
 ) => 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",
-					"--ansi",
-					"--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 }),
-	})
+export const pickWorkTarget: PickWorkTarget = (choices, command) =>
+	choose(
+		"Work on",
+		choices.map((choice, index) => ({
+			key: String(index),
+			label: choice.label,
+			plainLabel: choice.plainLabel,
+			value: choice.target,
+		})),
+		command,
+	)

package/src/workbase/workbase-choice.ts

@@ -1,43 +1,30 @@
 import { Effect } from "effect"
 import { resolve } from "node:path"
-import { FileSystemService } from "../services/FileSystemService"
 import { WorkbaseService } from "../services/WorkbaseService"
+import { choose } from "../utils/chooser"
 
 export type PickWorkbase = (
 	workbases: readonly string[],
+	command?: readonly string[],
 ) => Effect.Effect<string | null, Error>
 
-export const pickWorkbase: PickWorkbase = (workbases) =>
-	Effect.tryPromise({
-		try: async () => {
-			const input = workbases
-				.map((workbase, index) => `${index}\t${workbase}`)
-				.join("\n")
-			const process = Bun.spawn(
-				["fzf", "--delimiter=\t", "--with-nth=2..", "--prompt=Workbase> "],
-				{ 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}`)
-			const index = Number.parseInt(output.split("\t", 1)[0] ?? "", 10)
-			return workbases[index] ?? null
-		},
-		catch: (cause) =>
-			new Error("Failed to select a workbase with fzf", { cause }),
-	})
+export const pickWorkbase: PickWorkbase = (workbases, command) =>
+	choose(
+		"Workbase",
+		workbases.map((workbase, index) => ({
+			key: String(index),
+			label: workbase,
+			value: workbase,
+		})),
+		command,
+	)
 
 export const resolveWorkbase = (
 	startPath: string,
-	log: (message: string) => void,
 	pick: PickWorkbase = pickWorkbase,
 	inputAllowed = true,
 ) =>
 	Effect.gen(function* () {
-		const fs = yield* FileSystemService
 		const workbase = yield* WorkbaseService
 
 		return yield* workbase.discover(startPath).pipe(
@@ -59,18 +46,6 @@ export const resolveWorkbase = (
 						)
 					}
 
-					const fzf = yield* fs.runCommand(["which", "fzf"], {
-						captureOutput: true,
-					})
-					if (fzf.exitCode !== 0) {
-						for (const path of registered) log(path)
-						return yield* Effect.fail(
-							new Error(
-								"fzf is required to select a workbase; install fzf or run Agency from a registered workbase",
-							),
-						)
-					}
-
 					const selected = yield* pick(registered)
 					return selected ? yield* workbase.discover(selected) : null
 				}),