@markjaquith/agency 2.34.1 → 2.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.34.1",
+  "version": "2.36.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

package/src/utils/interactive.pty.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { join } from "node:path"
+import { cleanupTempDir, createTempDir } from "../test-utils"
+
+const projectRoot = join(import.meta.dir, "../..")
+const cliPath = join(projectRoot, "cli.ts")
+const tempDirs: string[] = []
+
+afterEach(() => Promise.all(tempDirs.splice(0).map(cleanupTempDir)))
+
+const modes = (terminal: Bun.Terminal) => ({
+	input: terminal.inputFlags,
+	output: terminal.outputFlags,
+	local: terminal.localFlags,
+	control: terminal.controlFlags,
+})
+
+const waitFor = async (condition: () => boolean, output: () => string) => {
+	const deadline = Date.now() + 8_000
+	while (!condition()) {
+		if (Date.now() >= deadline) {
+			throw new Error(`Timed out waiting for terminal output:\n${output()}`)
+		}
+		await Bun.sleep(10)
+	}
+}
+
+const waitForExit = (subprocess: Bun.Subprocess, output: () => string) =>
+	new Promise<number>((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(new Error(`Timed out waiting for CLI exit:\n${output()}`))
+		}, 8_000)
+		subprocess.exited.then(
+			(exitCode) => {
+				clearTimeout(timeout)
+				resolve(exitCode)
+			},
+			(error) => {
+				clearTimeout(timeout)
+				reject(error)
+			},
+		)
+	})
+
+const createWorkbase = async () => {
+	const root = await createTempDir()
+	tempDirs.push(root)
+	const initialized = Bun.spawnSync(
+		[process.execPath, cliPath, "init", root, "--silent"],
+		{ stdout: "pipe", stderr: "pipe" },
+	)
+	if (initialized.exitCode !== 0) {
+		throw new Error(new TextDecoder().decode(initialized.stderr))
+	}
+	return root
+}
+
+const runPrompt = async (
+	drive: (terminal: Bun.Terminal, output: () => string) => Promise<void>,
+) => {
+	const root = await createWorkbase()
+	const decoder = new TextDecoder()
+	let output = ""
+	const terminal = new Bun.Terminal({
+		cols: 80,
+		rows: 24,
+		data: (_terminal, bytes) => {
+			output += decoder.decode(bytes, { stream: true })
+		},
+	})
+	const initialModes = modes(terminal)
+	const subprocess = Bun.spawn([process.execPath, cliPath, "task", "new"], {
+		cwd: root,
+		env: { ...process.env, TERM: "xterm-256color" },
+		terminal,
+	})
+
+	try {
+		await waitFor(
+			() => output.includes("Task ID:"),
+			() => output,
+		)
+		const activeModes = modes(terminal)
+		expect(activeModes).not.toEqual(initialModes)
+		await drive(terminal, () => output)
+		const exitCode = await waitForExit(subprocess, () => output)
+		output += decoder.decode()
+		expect(exitCode).toBe(1)
+		expect(modes(terminal)).toEqual(initialModes)
+		expect(output.lastIndexOf("\x1b[?25h")).toBeGreaterThan(
+			output.lastIndexOf("\x1b[?25l"),
+		)
+		expect(output.lastIndexOf("\x1b[?2004l")).toBeGreaterThan(
+			output.lastIndexOf("\x1b[?2004h"),
+		)
+		return output
+	} finally {
+		if (subprocess.exitCode === null) {
+			subprocess.kill("SIGKILL")
+			await subprocess.exited
+		}
+		terminal.close()
+	}
+}
+
+describe("interactive CLI terminal restoration", () => {
+	test("restores terminal state after submission, resize, and escape", async () => {
+		const output = await runPrompt(async (terminal, currentOutput) => {
+			terminal.resize(30, 8)
+			terminal.write("pty-contract\r")
+			await waitFor(
+				() => currentOutput().includes("Ticket URL (optional):"),
+				currentOutput,
+			)
+			terminal.write("\x1b")
+		})
+
+		expect(output).toContain("Failed to read task input")
+	}, 12_000)
+
+	test("restores terminal state after ctrl-c", async () => {
+		const output = await runPrompt(async (terminal) => {
+			terminal.write("\x03")
+		})
+
+		expect(output).toContain("Failed to read task input")
+	}, 12_000)
+})

package/src/utils/interactive.test.tsx

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import { KeyCodes, type MockInput } from "@opentui/core/testing"
 import { testRender } from "@opentui/solid"
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
@@ -10,6 +11,34 @@ import {
 	interactiveRendererConfig,
 } from "./interactive"
 
+const submitEditedText = async (
+	edit: (input: MockInput) => void | Promise<void>,
+) => {
+	let submitted: string | null | undefined
+	const setup = await testRender(
+		() => (
+			<InteractiveTextPrompt
+				prompt="Text"
+				onDone={(value) => {
+					submitted = value
+				}}
+			/>
+		),
+		{ width: 60, height: 4 },
+	)
+	try {
+		await setup.renderer.setupTerminal()
+		await setup.renderOnce()
+		await Bun.sleep(0)
+		await edit(setup.mockInput)
+		setup.mockInput.pressEnter()
+		await setup.waitFor(() => submitted !== undefined)
+		return submitted
+	} finally {
+		setup.renderer.destroy()
+	}
+}
+
 describe("OpenTUI interaction", () => {
 	test("selects the Solid JSX runtime without the project preload", async () => {
 		const source = await Bun.file(
@@ -109,8 +138,8 @@ describe("OpenTUI interaction", () => {
 		expect(await selectAfter("down")).toBe("web")
 	})
 
-	test("uses printable j, k, and q characters as the fuzzy query", async () => {
-		for (const query of ["j", "k", "q"]) {
+	test("uses printable j, k, q, and ? characters as the fuzzy query", async () => {
+		for (const query of ["j", "k", "q", "?"]) {
 			let selected: string | null | undefined
 			const setup = await testRender(
 				() => (
@@ -141,6 +170,163 @@ describe("OpenTUI interaction", () => {
 		}
 	})
 
+	test("supports the readline movement and deletion contract", async () => {
+		const cases = [
+			{
+				name: "left arrow",
+				expected: "aXb",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressArrow("left")
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "home and end",
+				expected: "XabY",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey(KeyCodes.HOME)
+					await input.typeText("X")
+					input.pressKey(KeyCodes.END)
+					await input.typeText("Y")
+				},
+			},
+			{
+				name: "backspace and delete",
+				expected: "a",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressBackspace()
+					input.pressArrow("left")
+					input.pressKey(KeyCodes.DELETE)
+				},
+			},
+			{
+				name: "ctrl-a and ctrl-e",
+				expected: "XabY",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey("a", { ctrl: true })
+					await input.typeText("X")
+					input.pressKey("e", { ctrl: true })
+					await input.typeText("Y")
+				},
+			},
+			{
+				name: "ctrl-b and ctrl-f",
+				expected: "aXb",
+				edit: async (input: MockInput) => {
+					await input.typeText("ab")
+					input.pressKey("b", { ctrl: true })
+					input.pressKey("b", { ctrl: true })
+					input.pressKey("f", { ctrl: true })
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "meta-b and meta-f",
+				expected: "one Xtwo",
+				edit: async (input: MockInput) => {
+					await input.typeText("one two")
+					input.pressKey("b", { meta: true })
+					input.pressKey("b", { meta: true })
+					input.pressKey("f", { meta: true })
+					await input.typeText("X")
+				},
+			},
+			{
+				name: "ctrl-u",
+				expected: "c",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("u", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-k",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("k", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-w",
+				expected: "one ",
+				edit: async (input: MockInput) => {
+					await input.typeText("one two")
+					input.pressKey("w", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-d",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressArrow("left")
+					input.pressKey("d", { ctrl: true })
+				},
+			},
+			{
+				name: "ctrl-h",
+				expected: "ab",
+				edit: async (input: MockInput) => {
+					await input.typeText("abc")
+					input.pressKey("h", { ctrl: true })
+				},
+			},
+		]
+
+		for (const contract of cases) {
+			expect(await submitEditedText(contract.edit), contract.name).toBe(
+				contract.expected,
+			)
+		}
+	})
+
+	test("yanks the most recently killed text in both prompt inputs", async () => {
+		expect(
+			await submitEditedText(async (input) => {
+				await input.typeText("one two")
+				input.pressKey("w", { ctrl: true })
+				input.pressKey("y", { ctrl: true })
+			}),
+		).toBe("one two")
+
+		let selected: string | null | undefined
+		const setup = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Repository"
+					choices={[
+						{ key: "agency", label: "agency" },
+						{ key: "web", label: "web" },
+					]}
+					onDone={(value) => {
+						selected = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await setup.renderer.setupTerminal()
+			await setup.renderOnce()
+			await Bun.sleep(0)
+			await setup.mockInput.typeText("web")
+			setup.mockInput.pressKey("u", { ctrl: true })
+			setup.mockInput.pressKey("y", { ctrl: true })
+			setup.mockInput.pressEnter()
+			await setup.waitFor(() => selected !== undefined)
+			expect(selected).toBe("web")
+		} finally {
+			setup.renderer.destroy()
+		}
+	})
+
 	test("does not select an empty result and supports ctrl-u editing", async () => {
 		let selected: string | null | undefined
 		const setup = await testRender(
@@ -232,6 +418,98 @@ describe("OpenTUI interaction", () => {
 		}
 	})
 
+	test("keeps empty and single-item list boundaries safe", async () => {
+		let emptyResult: string | null | undefined
+		const empty = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Empty"
+					choices={[]}
+					onDone={(value) => {
+						emptyResult = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await empty.renderer.setupTerminal()
+			await empty.renderOnce()
+			await Bun.sleep(0)
+			empty.mockInput.pressArrow("up")
+			empty.mockInput.pressArrow("down")
+			empty.mockInput.pressKey("p", { ctrl: true })
+			empty.mockInput.pressKey("n", { ctrl: true })
+			empty.mockInput.pressEnter()
+			await Bun.sleep(0)
+			expect(emptyResult).toBeUndefined()
+			expect(empty.captureCharFrame()).toContain("No matches")
+		} finally {
+			empty.renderer.destroy()
+		}
+
+		for (const move of ["up", "down"] as const) {
+			let singleResult: string | null | undefined
+			const single = await testRender(
+				() => (
+					<InteractiveSelectPrompt
+						prompt="Single"
+						choices={[{ key: "one", label: "One" }]}
+						onDone={(value) => {
+							singleResult = value
+						}}
+					/>
+				),
+				{ width: 60, height: 4 },
+			)
+			try {
+				await single.renderer.setupTerminal()
+				await single.renderOnce()
+				await Bun.sleep(0)
+				single.mockInput.pressArrow(move)
+				single.mockInput.pressEnter()
+				await single.waitFor(() => singleResult !== undefined)
+				expect(singleResult).toBe("one")
+			} finally {
+				single.renderer.destroy()
+			}
+		}
+	})
+
+	test("remains usable after a narrow terminal resize", async () => {
+		let selected: string | null | undefined
+		const setup = await testRender(
+			() => (
+				<InteractiveSelectPrompt
+					prompt="Repository with a long prompt"
+					choices={[
+						{ key: "agency", label: "agency" },
+						{ key: "docs", label: "docs" },
+					]}
+					onDone={(value) => {
+						selected = value
+					}}
+				/>
+			),
+			{ width: 60, height: 4 },
+		)
+		try {
+			await setup.renderer.setupTerminal()
+			await setup.renderOnce()
+			await Bun.sleep(0)
+			setup.resize(18, 4)
+			await setup.renderOnce()
+			await setup.mockInput.typeText("docs")
+			await setup.renderOnce()
+			expect(setup.captureCharFrame()).toContain("> docs")
+			setup.mockInput.pressEnter()
+			await setup.waitFor(() => selected !== undefined)
+			expect(selected).toBe("docs")
+		} finally {
+			setup.renderer.destroy()
+		}
+	})
+
 	test("submits text and cancels with ctrl-c or escape", async () => {
 		let submitted: string | null | undefined
 		const input = await testRender(

package/src/utils/interactive.tsx

@@ -34,9 +34,77 @@ interface PromptProps<T> {
 const isCancel = (key: { name: string; ctrl: boolean }) =>
 	key.name === "escape" || (key.ctrl && key.name === "c")
 
+interface PromptKey {
+	readonly name: string
+	readonly ctrl: boolean
+	preventDefault(): void
+	stopPropagation(): void
+}
+
+const removedText = (before: string, after: string) => {
+	let start = 0
+	while (
+		start < before.length &&
+		start < after.length &&
+		before[start] === after[start]
+	) {
+		start++
+	}
+
+	let end = 0
+	while (
+		before[before.length - end - 1] === after[after.length - end - 1] &&
+		end < before.length - start &&
+		end < after.length - start
+	) {
+		end++
+	}
+
+	return before.slice(start, before.length - end)
+}
+
+const createReadlineEditing = (
+	getInput: () => TextareaRenderable | undefined,
+	onInput?: (value: string) => void,
+) => {
+	let value = ""
+	let killBuffer = ""
+	let beforeKill: string | undefined
+
+	return {
+		get value() {
+			return value
+		},
+		handleInput(next: string) {
+			if (beforeKill !== undefined) {
+				const killed = removedText(beforeKill, next)
+				if (killed) killBuffer = killed
+				beforeKill = undefined
+			}
+			value = next
+			onInput?.(next)
+		},
+		handleKey(key: PromptKey) {
+			const current = getInput()?.plainText
+			if (current !== undefined && current !== value) this.handleInput(current)
+			if (!key.ctrl) return false
+			if (key.name === "y") {
+				key.preventDefault()
+				key.stopPropagation()
+				if (killBuffer) getInput()?.insertText(killBuffer)
+				return true
+			}
+			if (key.name === "u" || key.name === "k" || key.name === "w") {
+				beforeKill = value
+			}
+			return false
+		},
+	}
+}
+
 export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 	let input: TextareaRenderable | undefined
-	let value = ""
+	const editing = createReadlineEditing(() => input)
 	useKeyboard((key) => {
 		if (isCancel(key)) {
 			key.preventDefault()
@@ -44,10 +112,11 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 			props.onDone(null)
 			return
 		}
+		if (editing.handleKey(key)) return
 		if (key.name !== "return") return
 		key.preventDefault()
 		key.stopPropagation()
-		props.onDone(value)
+		props.onDone(editing.value)
 	})
 
 	return (
@@ -59,7 +128,7 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 				wrapMode="word"
 				keyBindings={[{ name: "return", action: "submit" }]}
 				onContentChange={() => {
-					value = input?.plainText ?? ""
+					editing.handleInput(input?.plainText ?? "")
 				}}
 				ref={(next) => {
 					input = next
@@ -68,7 +137,9 @@ export const InteractiveTextPrompt = (props: PromptProps<string>) => {
 					})
 				}}
 			/>
-			<text fg="#6c7086">enter submit | esc cancel</text>
+			<text fg="#6c7086" wrapMode="none">
+				enter submit | esc cancel | ctrl-y yank
+			</text>
 		</box>
 	)
 }
@@ -145,6 +216,7 @@ export const fuzzyChoices = (
 export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 	let input: TextareaRenderable | undefined
 	const [query, setQuery] = createSignal("")
+	const editing = createReadlineEditing(() => input, setQuery)
 	const [selected, setSelected] = createSignal(0)
 	const choices = createMemo(() => fuzzyChoices(props.choices, query()))
 	const move = (offset: -1 | 1) => {
@@ -171,6 +243,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 			move(1)
 			return
 		}
+		if (editing.handleKey(key)) return
 		if (key.name !== "return") return
 		key.preventDefault()
 		key.stopPropagation()
@@ -207,7 +280,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 					placeholder="filter"
 					keyBindings={[{ name: "return", action: "submit" }]}
 					onContentChange={() => {
-						setQuery(input?.plainText ?? "")
+						editing.handleInput(input?.plainText ?? "")
 						setSelected(0)
 					}}
 					ref={(next) => {
@@ -232,7 +305,7 @@ export const InteractiveSelectPrompt = (props: SelectPromptProps) => {
 				</For>
 			</box>
 			<text fg="#6c7086" wrapMode="none">
-				enter select | esc cancel | ctrl-n/p or arrows
+				enter select | esc cancel | arrows/ctrl-n/p | ctrl-y yank
 			</text>
 		</box>
 	)