@markjaquith/agency 2.7.1 → 2.7.3

package/src/commands/task.ts

@@ -81,14 +81,16 @@ export const task = (
 		const cwd = options.cwd ?? process.cwd()
 
 		switch (options.subcommand) {
-			case "new":
-			case "create": {
-				const interactive = options.subcommand === "new" || !options.args[0]
+			case "new": {
+				if (options.inputAllowed === false) {
+					return yield* Effect.fail(
+						new Error(
+							"task new requires interactive input; use 'agency task create <id> --repo <alias>' for automation",
+						),
+					)
+				}
 				const id =
-					options.args[0] ??
-					(interactive
-						? (yield* interaction.text("Task ID: ")).trim()
-						: undefined)
+					options.args[0] ?? (yield* interaction.text("Task ID: ")).trim()
 				if (!id) {
 					return yield* Effect.fail(new Error("Task ID is required"))
 				}
@@ -99,42 +101,39 @@ export const task = (
 				let multiPhase = options.multiPhase ?? false
 				let repo = options.repo
 
-				if (interactive) {
-					if (options.ticketUrl === undefined) {
-						ticketUrl =
-							(yield* interaction.text("Ticket URL (optional): ")).trim() ||
-							null
-					}
-					if (options.description === undefined) {
-						description =
-							(yield* interaction.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", [
-								none,
-								...epicRecords.map((record) => record.id),
-							])
-							if (selected === null) {
-								return yield* Effect.fail(new Error("Task creation cancelled"))
-							}
-							epic = selected === none ? undefined : selected
-						}
-					}
-					if (options.multiPhase === undefined) {
-						const selected = yield* interaction.select("Task type", [
-							"single-phase",
-							"multi-phase",
+				if (options.ticketUrl === undefined) {
+					ticketUrl =
+						(yield* interaction.text("Ticket URL (optional): ")).trim() || null
+				}
+				if (options.description === undefined) {
+					description =
+						(yield* interaction.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", [
+							none,
+							...epicRecords.map((record) => record.id),
 						])
 						if (selected === null) {
 							return yield* Effect.fail(new Error("Task creation cancelled"))
 						}
-						multiPhase = selected === "multi-phase"
+						epic = selected === none ? undefined : selected
 					}
 				}
+				if (options.multiPhase === undefined) {
+					const selected = yield* interaction.select("Task type", [
+						"single-phase",
+						"multi-phase",
+					])
+					if (selected === null) {
+						return yield* Effect.fail(new Error("Task creation cancelled"))
+					}
+					multiPhase = selected === "multi-phase"
+				}
 
 				if (!multiPhase && !repo) {
 					const records = yield* repositories.list(cwd)
@@ -177,6 +176,39 @@ export const task = (
 				)
 				return
 			}
+			case "create": {
+				const id = options.args[0]
+				if (!id) {
+					return yield* Effect.fail(new Error("Task ID is required"))
+				}
+				const multiPhase = options.multiPhase ?? false
+				if (!multiPhase && !options.repo) {
+					return yield* Effect.fail(
+						new Error("Writable repository is required for task create"),
+					)
+				}
+				const record = yield* tasks.create(
+					{
+						id,
+						ticketUrl: options.ticketUrl?.trim() || null,
+						description: options.description?.trim() || undefined,
+						epic: options.epic,
+						multiPhase,
+						repo: options.repo,
+						repos: parseRepositoryReferences(options.references),
+						branch: multiPhase ? undefined : (options.branch ?? `task/${id}`),
+						base: multiPhase ? undefined : (options.base ?? "main"),
+					},
+					cwd,
+				)
+				const { content: _, ...output } = record
+				log(
+					options.json
+						? JSON.stringify(output, null, 2)
+						: `Created task '${record.id}'`,
+				)
+				return
+			}
 			case "list": {
 				const records = yield* tasks.list(cwd)
 				if (options.json) {
@@ -234,7 +266,7 @@ Usage: agency task <subcommand>
 
 Subcommands:
   new [id]              Create a task with guided input
-  create <id>           Create a task; omitted metadata uses defaults
+  create <id>           Create a task without prompting
   list                  List tasks
   show <id>             Show a task
   status <id> <status>  Set open, working, delegated, done, or dropped
@@ -250,6 +282,11 @@ Create options:
   --base <name>         Base branch (default: main)
   --multi-phase         Create a task container for phases
 
+Task creation is noninteractive. Single-phase tasks require --repo; use
+--multi-phase instead for a task container. Guided input is available only
+through task new, which fails when --no-input is set or no TTY is available.
+
 Options:
   --json                Output results as JSON
+  --no-input            Never open interactive task creation
 `

package/src/commands/validate.test.ts

@@ -108,6 +108,34 @@ pr: null
 		expect(discovered).toEqual(["/outside", "/selected"])
 	})
 
+	test("does not select a registered workbase when input is disabled", async () => {
+		const workbase = {
+			discover: () =>
+				Effect.fail({
+					_tag: "WorkbaseNotFoundError" as const,
+					message: "No Agency workbase found from /outside",
+				}),
+			listRegistered: () => Effect.succeed(["/selected"]),
+		}
+		const fs = {
+			runCommand: () => Effect.fail(new Error("unexpected fzf probe")),
+		}
+		const pick: PickWorkbase = () =>
+			Effect.fail(new Error("unexpected workbase selection"))
+
+		await expect(
+			Effect.runPromise(
+				validate(
+					{ cwd: "/outside", silent: true, inputAllowed: false },
+					pick,
+				).pipe(
+					Effect.provideService(WorkbaseService, workbase as never),
+					Effect.provideService(FileSystemService, fs as never),
+				) as Effect.Effect<void, unknown, never>,
+			),
+		).rejects.toThrow("provide an explicit path or run Agency from a workbase")
+	})
+
 	test("outputs the validation report as JSON", async () => {
 		await Bun.write(
 			join(root, "tasks/example/TASK.md"),

package/src/commands/validate.ts

@@ -27,7 +27,12 @@ export const validate = (
 		const startPath = options.path ?? options.cwd ?? process.cwd()
 		const root = options.path
 			? yield* workbase.discover(startPath)
-			: yield* resolveWorkbase(startPath, log, pick)
+			: yield* resolveWorkbase(
+					startPath,
+					log,
+					pick,
+					options.inputAllowed ?? true,
+				)
 		if (!root) return
 		const report = yield* workbase.validate(root)
 
@@ -61,4 +66,8 @@ graphs. The current or selected registered workbase is used when path is omitted
 
 Options:
   --json              Output the validation report as JSON
+  --no-input          Never open an interactive workbase selector
+
+When interactive input is unavailable, pass a path or run this command from a
+workbase. Registered-workbase selection otherwise fails.
 `

package/src/commands/work.test.ts

@@ -193,7 +193,12 @@ describe("work command", () => {
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
 			cli: "opencode",
-			args: ["opencode", "--continue"],
+			args: [
+				"opencode",
+				"--continue",
+				"--prompt",
+				"Work on the epic. Read /workbase/epics/delivery/EPIC.md.",
+			],
 			cwd: "/workbase/epics/delivery",
 		})
 	})
@@ -210,7 +215,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.shownTasks).toEqual(["delivery"])
-		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/delivery")
+		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
 	})
 
 	test("treats a positional value as a task ID when it is not a directory", async () => {
@@ -223,7 +228,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.shownTasks).toEqual(["delivery"])
-		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/delivery")
+		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
 	})
 
 	test("launches a multi-phase task agent without materializing", async () => {
@@ -238,7 +243,12 @@ describe("work command", () => {
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
 			cli: "opencode",
-			args: ["opencode", "--continue"],
+			args: [
+				"opencode",
+				"--continue",
+				"--prompt",
+				"Work on the task. Read /workbase/tasks/delivery/TASK.md.",
+			],
 			cwd: "/workbase/tasks/delivery",
 		})
 	})
@@ -257,7 +267,16 @@ describe("work command", () => {
 			"probe:opencode",
 			"launch:opencode",
 		])
-		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode",
+			args: [
+				"opencode",
+				"--continue",
+				"--prompt",
+				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
+			],
+			cwd: multiPhaseWorkspace.writablePath,
+		})
 		expect(harness.statusUpdates).toEqual([
 			"phase:example:implementation:working",
 		])
@@ -273,7 +292,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.events[0]).toBe("materialize")
-		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example")
+		expect(harness.launches[0]?.cwd).toBe(singlePhaseWorkspace.writablePath)
 	})
 
 	test("selects a target with fzf when no directory is provided", async () => {
@@ -307,9 +326,37 @@ describe("work command", () => {
 			"probe:opencode",
 			"launch:opencode",
 		])
-		expect(harness.launches[0]?.cwd).toBe(
-			"/workbase/tasks/delivery/phases/build",
-		)
+		expect(harness.launches[0]?.cwd).toBe(multiPhaseWorkspace.writablePath)
+	})
+
+	test("requires an explicit target when input is disabled", async () => {
+		const harness = createHarness()
+
+		await expect(
+			harness.run({
+				cwd: "/workbase",
+				opencode: true,
+				inputAllowed: false,
+			}),
+		).rejects.toThrow("provide a directory, task ID, or --epic")
+		expect(harness.events).toEqual([])
+	})
+
+	test("runs an explicit target when input is disabled", async () => {
+		const harness = createHarness({ existingDirectories: [] })
+
+		await harness.run({
+			cwd: "/workbase",
+			directory: "example",
+			opencode: true,
+			inputAllowed: false,
+		})
+
+		expect(harness.events).toEqual([
+			"materialize",
+			"probe:opencode",
+			"launch:opencode",
+		])
 	})
 
 	test("selects a registered workbase when local discovery fails", async () => {
@@ -338,6 +385,24 @@ describe("work command", () => {
 		])
 	})
 
+	test("does not select a registered workbase when input is disabled", async () => {
+		const harness = createHarness({
+			outsideWorkbase: true,
+			registeredWorkbases: ["/workbase"],
+			existingDirectories: [],
+		})
+
+		await expect(
+			harness.run({
+				cwd: "/outside",
+				directory: "example",
+				opencode: true,
+				inputAllowed: false,
+			}),
+		).rejects.toThrow("provide an explicit path or run Agency from a workbase")
+		expect(harness.events).toEqual([])
+	})
+
 	test("explains how to register a workbase when none are known", async () => {
 		const harness = createHarness({ outsideWorkbase: true })
 
@@ -387,7 +452,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
-	test("launches OpenCode in the task directory and continues its session", async () => {
+	test("launches OpenCode in the writable checkout with explicit context", async () => {
 		const harness = createHarness()
 
 		await harness.run({ taskId: "example", opencode: true })
@@ -400,8 +465,13 @@ describe("work command", () => {
 		expect(harness.launches).toEqual([
 			{
 				cli: "opencode",
-				args: ["opencode", "--continue"],
-				cwd: "/workbase/tasks/example",
+				args: [
+					"opencode",
+					"--continue",
+					"--prompt",
+					"Start the task. Read /workbase/tasks/example/TASK.md.",
+				],
+				cwd: singlePhaseWorkspace.writablePath,
 			},
 		])
 		expect(harness.statusUpdates).toEqual(["task:example:working"])
@@ -411,7 +481,7 @@ describe("work command", () => {
 		])
 	})
 
-	test("continues OpenCode for a multi-phase task", async () => {
+	test("continues OpenCode with explicit task and phase context", async () => {
 		const harness = createHarness({ workspace: multiPhaseWorkspace })
 
 		await harness.run({
@@ -420,7 +490,16 @@ describe("work command", () => {
 			opencode: true,
 		})
 
-		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode",
+			args: [
+				"opencode",
+				"--continue",
+				"--prompt",
+				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
+			],
+			cwd: multiPhaseWorkspace.writablePath,
+		})
 	})
 
 	test("automatically falls back to Claude", async () => {
@@ -432,7 +511,7 @@ describe("work command", () => {
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
 			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: "/workbase/tasks/example",
+			cwd: singlePhaseWorkspace.writablePath,
 		})
 	})
 
@@ -456,7 +535,7 @@ describe("work command", () => {
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
 			args: ["claude", "Start the task. Read /workbase/tasks/example/TASK.md."],
-			cwd: "/workbase/tasks/example",
+			cwd: singlePhaseWorkspace.writablePath,
 		})
 	})
 
@@ -493,7 +572,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching command: opencode --continue (cwd: /workbase/tasks/example)",
+			"Launching command: opencode --continue --prompt 'Start the task. Read /workbase/tasks/example/TASK.md.' (cwd: /workbase/tasks/example/code/agency)",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 

package/src/commands/work.ts

@@ -84,7 +84,8 @@ export const work = (
 			? yield* fs.isDirectory(directoryPath)
 			: false
 		const startPath = isDirectory && directoryPath ? directoryPath : cwd
-		const root = yield* resolveWorkbase(startPath, log, pickBase)
+		const inputAllowed = options.inputAllowed ?? true
+		const root = yield* resolveWorkbase(startPath, log, pickBase, inputAllowed)
 		if (!root) return
 
 		let target: WorkTarget | null = null
@@ -148,6 +149,13 @@ export const work = (
 		}
 
 		if (!target) {
+			if (!inputAllowed) {
+				return yield* Effect.fail(
+					new Error(
+						"Work target selection requires interactive input; provide a directory, task ID, or --epic <id>",
+					),
+				)
+			}
 			const epicRecords = yield* epics.list(root)
 			const taskRecords = yield* tasks.list(root)
 			const phaseRecords = []
@@ -206,7 +214,7 @@ export const work = (
 			prompt = workspace.phasePath
 				? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
 				: `Start the task. Read ${workspace.taskPath}.`
-			launchPath = dirname(target.path)
+			launchPath = workspace.writablePath
 		}
 
 		const requested = options.claude ? "claude" : "opencode"
@@ -227,7 +235,8 @@ export const work = (
 			yield* tasks.setStatus(target.taskId, "working", root)
 		}
 
-		const args = cli === "opencode" ? ["--continue"] : [prompt]
+		const args =
+			cli === "opencode" ? ["--continue", "--prompt", prompt] : [prompt]
 		verboseLog(
 			`Launching command: ${formatCommand([cli, ...args])} (cwd: ${launchPath})`,
 		)
@@ -246,4 +255,8 @@ Options:
   --epic <id>         Work on an epic
   --opencode           Require OpenCode
   --claude             Require Claude Code
+  --no-input          Never open an interactive selector
+
+Without interactive input, provide a directory, task ID, or --epic and run the
+command from a workbase. Workbase and target selection otherwise fail.
 `

package/src/services/PullRequestService.test.ts

@@ -314,6 +314,20 @@ process.exit(${exitCode})
 		expect(await Bun.file(ghCallPath).exists()).toBe(false)
 	})
 
+	test("blocks PR creation when workbase validation fails", async () => {
+		await createTask()
+		await materialize()
+		await mkdir(join(root, "tasks", "missing-document"), { recursive: true })
+		await writeFakeGh({ stdout: "https://github.com/example/agency/pull/45" })
+
+		await expect(createPullRequest()).rejects.toThrow(
+			"Required document is missing",
+		)
+
+		await expectRemoteBranch("task/example", false)
+		expect(await Bun.file(ghCallPath).exists()).toBe(false)
+	})
+
 	test("reports push failure and does not invoke gh", async () => {
 		await createTask()
 		await materialize()

package/src/services/WorktreeService.test.ts

@@ -85,7 +85,7 @@ describe("WorktreeService", () => {
 		expect(new TextDecoder().decode(branch.stdout).trim()).toBe("task/example")
 	})
 
-	test("does not fetch origins for existing worktrees", async () => {
+	test("does not fetch the origin for an existing writable worktree", async () => {
 		await runTestEffect(
 			TaskService.pipe(
 				Effect.flatMap((service) =>
@@ -94,7 +94,6 @@ describe("WorktreeService", () => {
 							id: "existing",
 							ticketUrl: "https://example.com/task",
 							repo: "agency",
-							repos: [{ repo: "effect", ref: "main" }],
 							branch: "task/existing",
 							base: "main",
 						},
@@ -114,6 +113,50 @@ describe("WorktreeService", () => {
 			["remote", "set-url", "origin", join(root, "missing")],
 			join(root, "repos/agency"),
 		)
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("existing", undefined, root),
+					),
+				),
+			),
+		).resolves.toMatchObject({ repo: "agency" })
+	})
+
+	test("reuses an immutable reference checkout without fetching", async () => {
+		const commit = new TextDecoder()
+			.decode(
+				Bun.spawnSync(
+					["git", "-C", join(root, "repos/effect"), "rev-parse", "main"],
+					{ stdout: "pipe" },
+				).stdout,
+			)
+			.trim()
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "immutable-reference",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: commit }],
+							branch: "task/immutable-reference",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("immutable-reference", undefined, root),
+				),
+			),
+		)
 		await git(
 			["remote", "set-url", "origin", join(root, "missing")],
 			join(root, "repos/effect"),
@@ -123,11 +166,44 @@ describe("WorktreeService", () => {
 			runTestEffect(
 				WorktreeService.pipe(
 					Effect.flatMap((service) =>
-						service.materialize("existing", undefined, root),
+						service.materialize("immutable-reference", undefined, root),
 					),
 				),
 			),
-		).resolves.toMatchObject({ repo: "agency" })
+		).resolves.toMatchObject({ repos: [{ repo: "effect", ref: commit }] })
+	})
+
+	test("stops before materializing when workbase validation fails", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "valid-target",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							branch: "task/valid-target",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await mkdir(join(root, "tasks", "missing-document"), { recursive: true })
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("valid-target", undefined, root),
+					),
+				),
+			),
+		).rejects.toThrow("Required document is missing")
+		expect(
+			await Bun.file(join(root, "tasks", "valid-target", "code")).exists(),
+		).toBe(false)
 	})
 
 	test("uses a configured worktree creation command", async () => {
@@ -330,7 +406,7 @@ describe("WorktreeService", () => {
 				repo: "missing",
 				base: "main",
 				config: { version: 2 },
-				expected: "Repository alias 'missing' does not exist",
+				expected: "Unknown repository alias 'missing'",
 			},
 			{
 				id: "bad-base",
@@ -392,6 +468,7 @@ pr: null
 					),
 				),
 			).rejects.toThrow(fixture.expected)
+			await rm(taskDirectory, { recursive: true, force: true })
 		}
 	})
 
@@ -561,7 +638,7 @@ pr: null
 		).rejects.toThrow("is not registered to branch 'task/expected'")
 	})
 
-	test("rejects a reused reference checkout after its ref advances", async () => {
+	test("fetches a moving ref before checking a reused reference checkout", async () => {
 		await runTestEffect(
 			TaskService.pipe(
 				Effect.flatMap((service) =>
@@ -570,7 +647,7 @@ pr: null
 							id: "pinned-reference",
 							ticketUrl: "https://example.com/task",
 							repo: "agency",
-							repos: [{ repo: "effect", ref: "main" }],
+							repos: [{ repo: "effect", ref: "origin/main" }],
 							branch: "task/pinned-reference",
 							base: "main",
 						},
@@ -590,7 +667,6 @@ pr: null
 		await Bun.write(join(source, "README.md"), "updated\n")
 		await git(["add", "README.md"], source)
 		await git(["-c", "commit.gpgsign=false", "commit", "-m", "update"], source)
-		await git(["push", join(root, "repos/effect"), "main"], source)
 
 		await expect(
 			runTestEffect(
@@ -600,7 +676,7 @@ pr: null
 					),
 				),
 			),
-		).rejects.toThrow("does not match reference 'main'")
+		).rejects.toThrow("does not match reference 'origin/main'")
 	})
 
 	test("rejects a reference checkout attached to a branch", async () => {