@markjaquith/agency 2.4.0 → 2.6.0

package/src/commands/work.test.ts

@@ -9,6 +9,8 @@ import { WorktreeService } from "../services/WorktreeService"
 import { captureLogs } from "../test-utils"
 import { work } from "./work"
 import type { PickWorkTarget } from "../workbase/work-target"
+import type { PickWorkbase } from "../workbase/workbase-choice"
+import type { Progress } from "../utils/progress"
 
 type ExecutionWorkspace = Effect.Effect.Success<
 	ReturnType<WorktreeService["materialize"]>
@@ -42,11 +44,15 @@ interface HarnessOptions {
 	readonly epicRecords?: readonly any[]
 	readonly taskRecords?: readonly any[]
 	readonly phaseRecords?: readonly any[]
+	readonly outsideWorkbase?: boolean
+	readonly registeredWorkbases?: readonly string[]
 }
 
 const createHarness = (options: HarnessOptions = {}) => {
 	const events: string[] = []
 	const probes: string[] = []
+	const statusUpdates: string[] = []
+	const progressUpdates: string[] = []
 	const launches: Array<{
 		cli: string
 		args: readonly string[]
@@ -70,7 +76,14 @@ const createHarness = (options: HarnessOptions = {}) => {
 		},
 	}
 	const workbase = {
-		discover: () => Effect.succeed("/workbase"),
+		discover: (path: string) =>
+			options.outsideWorkbase && path === "/outside"
+				? Effect.fail({
+						_tag: "WorkbaseNotFoundError" as const,
+						message: "No Agency workbase found from /outside",
+					})
+				: Effect.succeed("/workbase"),
+		listRegistered: () => Effect.succeed(options.registeredWorkbases ?? []),
 	}
 	const epics = {
 		show: (id: string) =>
@@ -91,6 +104,10 @@ const createHarness = (options: HarnessOptions = {}) => {
 					: { repo: "agency", branch: `task/${id}`, base: "main" },
 			}),
 		list: () => Effect.succeed(options.taskRecords ?? []),
+		setStatus: (id: string, status: string) => {
+			statusUpdates.push(`task:${id}:${status}`)
+			return Effect.void
+		},
 	}
 	const phases = {
 		show: (taskId: string, id: string) =>
@@ -101,6 +118,10 @@ const createHarness = (options: HarnessOptions = {}) => {
 				data: { repo: "agency", branch: `task/${id}`, base: "main" },
 			}),
 		list: () => Effect.succeed(options.phaseRecords ?? []),
+		setStatus: (taskId: string, id: string, status: string) => {
+			statusUpdates.push(`phase:${taskId}:${id}:${status}`)
+			return Effect.void
+		},
 	}
 	const fs = {
 		runCommand: (args: readonly string[]) => {
@@ -119,12 +140,19 @@ const createHarness = (options: HarnessOptions = {}) => {
 		launches.push({ cli, args, cwd })
 	}
 	const defaultPick: PickWorkTarget = () => Effect.succeed(null)
+	const defaultPickWorkbase: PickWorkbase = () => Effect.succeed(null)
+	const progress: Progress = {
+		start: (message) => progressUpdates.push(`start:${message}`),
+		succeed: (message) => progressUpdates.push(`succeed:${message}`),
+		fail: (message) => progressUpdates.push(`fail:${message}`),
+	}
 	const run = (
 		commandOptions: Parameters<typeof work>[0],
 		pick: PickWorkTarget = defaultPick,
+		pickBase: PickWorkbase = defaultPickWorkbase,
 	) =>
 		Effect.runPromise(
-			work(commandOptions, launch, pick).pipe(
+			work(commandOptions, launch, pick, progress, pickBase).pipe(
 				Effect.provideService(WorktreeService, worktrees as never),
 				Effect.provideService(FileSystemService, fs as never),
 				Effect.provideService(WorkbaseService, workbase as never),
@@ -134,7 +162,15 @@ const createHarness = (options: HarnessOptions = {}) => {
 			) as Effect.Effect<void, unknown, never>,
 		)
 
-	return { events, probes, launches, materializeOptions, run }
+	return {
+		events,
+		probes,
+		launches,
+		materializeOptions,
+		statusUpdates,
+		progressUpdates,
+		run,
+	}
 }
 
 describe("work command", () => {
@@ -146,11 +182,7 @@ describe("work command", () => {
 		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.",
-			],
+			args: ["opencode", "--continue"],
 			cwd: "/workbase/epics/delivery",
 		})
 	})
@@ -163,11 +195,7 @@ describe("work command", () => {
 		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.",
-			],
+			args: ["opencode", "--continue"],
 			cwd: "/workbase/tasks/delivery",
 		})
 	})
@@ -185,9 +213,10 @@ describe("work command", () => {
 			"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.",
-		)
+		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
+		expect(harness.statusUpdates).toEqual([
+			"phase:example:implementation:working",
+		])
 	})
 
 	test("infers a single-phase task from a nested checkout directory", async () => {
@@ -199,7 +228,7 @@ describe("work command", () => {
 		})
 
 		expect(harness.events[0]).toBe("materialize")
-		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example/code/agency")
+		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example")
 	})
 
 	test("selects a target with fzf outside an entity directory", async () => {
@@ -234,8 +263,43 @@ describe("work command", () => {
 			"launch:opencode",
 		])
 		expect(harness.launches[0]?.cwd).toBe(
-			"/workbase/tasks/example/phases/implementation/code/agency",
+			"/workbase/tasks/delivery/phases/build",
+		)
+	})
+
+	test("selects a registered workbase when local discovery fails", async () => {
+		const harness = createHarness({
+			outsideWorkbase: true,
+			registeredWorkbases: ["/first", "/workbase"],
+		})
+		const selections: string[][] = []
+		const pickBase: PickWorkbase = (workbases) => {
+			selections.push([...workbases])
+			return Effect.succeed("/workbase")
+		}
+
+		await harness.run(
+			{ cwd: "/outside", taskId: "example", opencode: true },
+			undefined,
+			pickBase,
 		)
+
+		expect(selections).toEqual([["/first", "/workbase"]])
+		expect(harness.events).toEqual([
+			"probe:fzf",
+			"materialize",
+			"probe:opencode",
+			"launch:opencode",
+		])
+	})
+
+	test("explains how to register a workbase when none are known", async () => {
+		const harness = createHarness({ outsideWorkbase: true })
+
+		await expect(harness.run({ cwd: "/outside" })).rejects.toThrow(
+			"agency workbase add <path>",
+		)
+		expect(harness.events).toEqual([])
 	})
 
 	test("prints the target tree when fzf is unavailable", async () => {
@@ -278,7 +342,7 @@ describe("work command", () => {
 		expect(harness.events).toEqual([])
 	})
 
-	test("launches OpenCode in the writable checkout with the single-phase prompt", async () => {
+	test("launches OpenCode in the task directory and continues its session", async () => {
 		const harness = createHarness()
 
 		await harness.run({ taskId: "example", opencode: true })
@@ -291,17 +355,18 @@ describe("work command", () => {
 		expect(harness.launches).toEqual([
 			{
 				cli: "opencode",
-				args: [
-					"opencode",
-					"--prompt",
-					"Start the task. Read /workbase/tasks/example/TASK.md.",
-				],
-				cwd: "/workbase/tasks/example/code/agency",
+				args: ["opencode", "--continue"],
+				cwd: "/workbase/tasks/example",
 			},
 		])
+		expect(harness.statusUpdates).toEqual(["task:example:working"])
+		expect(harness.progressUpdates).toEqual([
+			"start:Preparing workspace...",
+			"succeed:Workspace ready",
+		])
 	})
 
-	test("includes absolute task and phase paths in a multi-phase prompt", async () => {
+	test("continues OpenCode for a multi-phase task", async () => {
 		const harness = createHarness({ workspace: multiPhaseWorkspace })
 
 		await harness.run({
@@ -310,11 +375,7 @@ describe("work command", () => {
 			opencode: true,
 		})
 
-		expect(harness.launches[0]?.args).toEqual([
-			"opencode",
-			"--prompt",
-			"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
-		])
+		expect(harness.launches[0]?.args).toEqual(["opencode", "--continue"])
 	})
 
 	test("automatically falls back to Claude", async () => {
@@ -326,7 +387,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/code/agency",
+			cwd: "/workbase/tasks/example",
 		})
 	})
 
@@ -338,6 +399,7 @@ describe("work command", () => {
 		).rejects.toThrow("opencode CLI tool not found")
 		expect(harness.probes).toEqual(["opencode"])
 		expect(harness.launches).toEqual([])
+		expect(harness.statusUpdates).toEqual([])
 	})
 
 	test("launches explicitly requested Claude", async () => {
@@ -349,7 +411,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/code/agency",
+			cwd: "/workbase/tasks/example",
 		})
 	})
 
@@ -374,6 +436,10 @@ describe("work command", () => {
 			"materialization failed",
 		)
 		expect(harness.events).toEqual(["materialize"])
+		expect(harness.progressUpdates).toEqual([
+			"start:Preparing workspace...",
+			"fail:Workspace preparation failed",
+		])
 	})
 
 	test("respects silent and verbose logging options", async () => {
@@ -382,7 +448,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching opencode in /workbase/tasks/example/code/agency",
+			"Launching opencode in /workbase/tasks/example",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 

package/src/commands/work.ts

@@ -9,12 +9,18 @@ import { TaskService } from "../services/TaskService"
 import { PhaseService } from "../services/PhaseService"
 import { createLoggers } from "../utils/effect"
 import { execvp } from "../utils/exec"
+import { createProgress, type Progress } from "../utils/progress"
 import {
 	buildWorkTargetChoices,
 	pickWorkTarget,
 	type PickWorkTarget,
 	type WorkTarget,
 } from "../workbase/work-target"
+import {
+	pickWorkbase,
+	resolveWorkbase,
+	type PickWorkbase,
+} from "../workbase/workbase-choice"
 
 interface WorkOptions extends BaseCommandOptions {
 	readonly taskId?: string
@@ -35,6 +41,8 @@ export const work = (
 	options: WorkOptions = {},
 	launch: LaunchAgent = launchAgent,
 	pick: PickWorkTarget = pickWorkTarget,
+	progress: Progress = createProgress(options),
+	pickBase: PickWorkbase = pickWorkbase,
 ) =>
 	Effect.gen(function* () {
 		if (options.opencode && options.claude) {
@@ -56,7 +64,8 @@ export const work = (
 		const phases = yield* PhaseService
 		const { log, verboseLog } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
-		const root = yield* workbase.discover(cwd)
+		const root = yield* resolveWorkbase(cwd, log, pickBase)
+		if (!root) return
 
 		let target: WorkTarget | null = null
 		if (options.epicId) {
@@ -155,16 +164,21 @@ export const work = (
 		} else {
 			const taskId = target.taskId
 			const phaseId = target.kind === "phase" ? target.phaseId : undefined
-			const workspace = yield* worktrees.materialize(
-				taskId,
-				phaseId,
-				root,
-				options,
-			)
+			progress.start("Preparing workspace...")
+			const workspace = yield* worktrees
+				.materialize(taskId, phaseId, root, options)
+				.pipe(
+					Effect.tap(() =>
+						Effect.sync(() => progress.succeed("Workspace ready")),
+					),
+					Effect.tapError(() =>
+						Effect.sync(() => progress.fail("Workspace preparation failed")),
+					),
+				)
 			prompt = workspace.phasePath
 				? `Start the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
 				: `Start the task. Read ${workspace.taskPath}.`
-			launchPath = workspace.writablePath
+			launchPath = dirname(target.path)
 		}
 
 		const requested = options.claude ? "claude" : "opencode"
@@ -179,9 +193,14 @@ export const work = (
 		if (available.exitCode !== 0) {
 			return yield* Effect.fail(new Error(`${cli} CLI tool not found`))
 		}
+		if (target.kind === "phase") {
+			yield* phases.setStatus(target.taskId, target.phaseId, "working", root)
+		} else if (target.kind === "task" && !target.multiPhase) {
+			yield* tasks.setStatus(target.taskId, "working", root)
+		}
 
 		verboseLog(`Launching ${cli} in ${launchPath}`)
-		const args = cli === "opencode" ? ["--prompt", prompt] : [prompt]
+		const args = cli === "opencode" ? ["--continue"] : [prompt]
 		launch(cli, [cli, ...args], launchPath)
 	})
 
@@ -189,7 +208,8 @@ export const help = `
 Usage: agency work [<task-id> [phase-id] | --epic <epic-id>]
 
 Launch an agent for the current epic, task, or phase. Outside an entity
-directory, select one with fzf.
+directory, select one with fzf. Outside a workbase, select a registered
+workbase first.
 
 Options:
   --epic <id>         Work on an epic

package/src/commands/workbase.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
+import { join } from "node:path"
+import {
+	captureLogs,
+	cleanupTempDir,
+	createTempDir,
+	runTestEffect,
+} from "../test-utils"
+import { workbase } from "./workbase"
+
+describe("workbase command", () => {
+	let root: string
+	let configDirectory: string
+
+	beforeEach(async () => {
+		root = await createTempDir()
+		configDirectory = join(root, "config")
+		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
+	})
+
+	afterEach(async () => cleanupTempDir(root))
+
+	test("adds and lists workbases as JSON", async () => {
+		const added = await captureLogs(() =>
+			runTestEffect(
+				workbase({
+					subcommand: "add",
+					args: [root],
+					configDirectory,
+					json: true,
+				}),
+			),
+		)
+		const path = JSON.parse(added[0]!).path
+
+		const listed = await captureLogs(() =>
+			runTestEffect(
+				workbase({
+					subcommand: "list",
+					args: [],
+					configDirectory,
+					json: true,
+				}),
+			),
+		)
+
+		expect(JSON.parse(listed[0]!)).toEqual([path])
+	})
+
+	test("requires an add path", async () => {
+		await expect(
+			runTestEffect(
+				workbase({
+					subcommand: "add",
+					args: [],
+					configDirectory,
+					silent: true,
+				}),
+			),
+		).rejects.toThrow("Usage: agency workbase add <path>")
+	})
+})

package/src/commands/workbase.ts

@@ -0,0 +1,58 @@
+import { Effect } from "effect"
+import type { BaseCommandOptions } from "../utils/command"
+import { WorkbaseService } from "../services/WorkbaseService"
+import { createLoggers } from "../utils/effect"
+
+interface WorkbaseOptions extends BaseCommandOptions {
+	readonly subcommand?: string
+	readonly args: readonly string[]
+	readonly configDirectory?: string
+}
+
+export const workbase = (options: WorkbaseOptions) =>
+	Effect.gen(function* () {
+		const service = yield* WorkbaseService
+		const { log } = createLoggers(options)
+
+		switch (options.subcommand) {
+			case "add": {
+				const path = options.args[0]
+				if (!path) {
+					return yield* Effect.fail(
+						new Error("Usage: agency workbase add <path>"),
+					)
+				}
+				const root = yield* service.register(path, options.configDirectory)
+				log(
+					options.json
+						? JSON.stringify({ path: root }, null, 2)
+						: `Added workbase ${root}`,
+				)
+				return
+			}
+			case "list": {
+				const workbases = yield* service.listRegistered(options.configDirectory)
+				if (options.json) {
+					log(JSON.stringify(workbases, null, 2))
+				} else {
+					for (const path of workbases) log(path)
+				}
+				return
+			}
+			default:
+				return yield* Effect.fail(
+					new Error("Subcommand is required. Available: add, list"),
+				)
+		}
+	})
+
+export const help = `
+Usage: agency workbase <subcommand>
+
+Subcommands:
+  add <path>  Register an Agency workbase
+  list        List registered workbases
+
+Options:
+  --json      Output results as JSON
+`