@markjaquith/agency 2.6.0 → 2.7.1

package/README.md

@@ -230,7 +230,7 @@ agency repo link backend ~/Dev/backend
 agency task new
 
 agency validate
-agency work refresh-copy
+agency work tasks/refresh-copy
 agency pr create refresh-copy
 ```
 
@@ -350,21 +350,21 @@ before moving files, refuses dirty worktrees, and preserves branches.
 ### Work and Pull Requests
 
 ```text
-agency work [<task-id> [phase-id] | --epic <epic-id>] [--opencode | --claude]
+agency work [<directory> | --epic <epic-id>] [--opencode | --claude]
 agency pr create <task-id> [phase-id] [--draft] [--json]
 ```
 
-`agency work` infers an epic, task, or phase from the current directory. From
-elsewhere in the workbase, it presents the full hierarchy in `fzf`. Outside a
-workbase, it first presents the registered workbases, then the selected
+`agency work` presents the full hierarchy in `fzf`. Pass a directory, including
+`.` for the current directory, to infer its epic, task, or phase. Outside a
+workbase, Agency first presents the registered workbases, then the selected
 workbase's hierarchy. If `fzf` is not installed, Agency prints the available
-choices and asks for an explicit target.
+choices and asks for an explicit directory.
 
 Epic and multi-phase task targets launch orchestration agents beside their
 documents. Single-phase tasks and phases fetch repositories, create or reuse
 worktrees under `code/`, and launch an execution agent in the writable checkout
-with absolute context paths. Explicit task, phase, and `--epic` targets override
-current-directory inference.
+with absolute context paths. An explicit directory or `--epic` target bypasses
+the hierarchy chooser.
 
 Each writable `(repo, branch)` pair may belong to only one task or phase. Agency
 validation reports duplicate ownership, and `agency work` checks Git's worktree

package/cli.ts

@@ -239,11 +239,15 @@ const commands: Record<string, Command> = {
 				console.log(workHelp)
 				return
 			}
+			if (args.length > 1) {
+				throw new Error(
+					"Usage: agency work [<directory-or-task-id> | --epic <epic-id>]",
+				)
+			}
 
 			await runCommand(
 				work({
-					taskId: args[0],
-					phaseId: args[1],
+					directory: args[0],
 					epicId: options.epic,
 					silent: options.silent,
 					verbose: options.verbose,
@@ -299,7 +303,7 @@ Commands:
   phase <subcommand>     Manage task phases
   archive <type>         Archive a work item
   task <subcommand>      Manage tasks
-  work [task] [phase]    Work on an epic, task, or phase
+  work [directory|task]  Work on an epic, task, or phase
   pr create              Create a pull request for an execution unit
   repo <subcommand>      Manage workbase repositories
   status                 Show status for the current workbase
@@ -314,7 +318,7 @@ Global Options:
 Examples:
   agency init                         # Initialize the current directory
   agency task list                    # List tasks
-  agency work refresh-cli-copy        # Start working on a task
+  agency work tasks/refresh-cli-copy  # Start working on a task
 
 For more information about a command, run:
   agency <command> --help

package/package.json

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

package/skills/agency/SKILL.md

@@ -246,15 +246,15 @@ Outside a workbase, omitting path opens the registered-workbase picker.
 
 ```bash
 agency work
-agency work <task-id> [phase-id]
+agency work <directory>
 agency work --epic <epic-id>
 ```
 
 Use `--opencode` or `--claude` to require a specific agent. This command fetches
 repositories for execution targets, creates or reuses their worktrees, and
-replaces the current process with the selected agent. It infers the nearest
-epic, task, or phase from the current directory; otherwise it opens an `fzf`
-picker containing the workbase hierarchy.
+replaces the current process with the selected agent. With no directory it opens
+an `fzf` picker containing the workbase hierarchy. Pass `.`, or another
+directory, to infer the nearest epic, task, or phase.
 Outside a workbase, it first opens a picker containing registered workbases.
 
 Epic and multi-phase task targets are orchestration sessions launched beside

package/src/commands/init.test.ts

@@ -39,6 +39,9 @@ describe("init command", () => {
 		expect(
 			await Bun.file(join(root, ".opencode/opencode.jsonc")).text(),
 		).toContain('"path": "../tasks"')
+		expect(
+			await Bun.file(join(root, ".opencode/opencode.jsonc")).text(),
+		).toContain(`"${join(root, "tasks")}/*": "allow"`)
 	})
 
 	test("preserves existing gitignore entries", async () => {

package/src/commands/work.test.ts

@@ -46,12 +46,14 @@ interface HarnessOptions {
 	readonly phaseRecords?: readonly any[]
 	readonly outsideWorkbase?: boolean
 	readonly registeredWorkbases?: readonly string[]
+	readonly existingDirectories?: readonly string[]
 }
 
 const createHarness = (options: HarnessOptions = {}) => {
 	const events: string[] = []
 	const probes: string[] = []
 	const statusUpdates: string[] = []
+	const shownTasks: string[] = []
 	const progressUpdates: string[] = []
 	const launches: Array<{
 		cli: string
@@ -95,14 +97,16 @@ const createHarness = (options: HarnessOptions = {}) => {
 		list: () => Effect.succeed(options.epicRecords ?? []),
 	}
 	const tasks = {
-		show: (id: string) =>
-			Effect.succeed({
+		show: (id: string) => {
+			shownTasks.push(id)
+			return Effect.succeed({
 				id,
 				path: `/workbase/tasks/${id}/TASK.md`,
 				data: options.multiPhaseTasks?.includes(id)
 					? { phases: [] }
 					: { repo: "agency", branch: `task/${id}`, base: "main" },
-			}),
+			})
+		},
 		list: () => Effect.succeed(options.taskRecords ?? []),
 		setStatus: (id: string, status: string) => {
 			statusUpdates.push(`task:${id}:${status}`)
@@ -124,6 +128,8 @@ const createHarness = (options: HarnessOptions = {}) => {
 		},
 	}
 	const fs = {
+		isDirectory: (path: string) =>
+			Effect.succeed(options.existingDirectories?.includes(path) ?? true),
 		runCommand: (args: readonly string[]) => {
 			const cli = args[1] as "opencode" | "claude"
 			events.push(`probe:${cli}`)
@@ -168,6 +174,7 @@ const createHarness = (options: HarnessOptions = {}) => {
 		launches,
 		materializeOptions,
 		statusUpdates,
+		shownTasks,
 		progressUpdates,
 		run,
 	}
@@ -177,7 +184,11 @@ describe("work command", () => {
 	test("launches an epic agent from an epic directory", async () => {
 		const harness = createHarness()
 
-		await harness.run({ cwd: "/workbase/epics/delivery", opencode: true })
+		await harness.run({
+			cwd: "/workbase/epics/delivery",
+			directory: ".",
+			opencode: true,
+		})
 
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
@@ -187,10 +198,42 @@ describe("work command", () => {
 		})
 	})
 
+	test("resolves an existing positional path before treating it as a task ID", async () => {
+		const harness = createHarness({
+			existingDirectories: ["/workbase/tasks/delivery"],
+		})
+
+		await harness.run({
+			cwd: "/workbase/tasks/delivery",
+			directory: ".",
+			opencode: true,
+		})
+
+		expect(harness.shownTasks).toEqual(["delivery"])
+		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/delivery")
+	})
+
+	test("treats a positional value as a task ID when it is not a directory", async () => {
+		const harness = createHarness({ existingDirectories: [] })
+
+		await harness.run({
+			cwd: "/workbase",
+			directory: "delivery",
+			opencode: true,
+		})
+
+		expect(harness.shownTasks).toEqual(["delivery"])
+		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/delivery")
+	})
+
 	test("launches a multi-phase task agent without materializing", async () => {
 		const harness = createHarness({ multiPhaseTasks: ["delivery"] })
 
-		await harness.run({ cwd: "/workbase/tasks/delivery", opencode: true })
+		await harness.run({
+			cwd: "/workbase/tasks/delivery",
+			directory: ".",
+			opencode: true,
+		})
 
 		expect(harness.events).toEqual(["probe:opencode", "launch:opencode"])
 		expect(harness.launches[0]).toEqual({
@@ -205,6 +248,7 @@ describe("work command", () => {
 
 		await harness.run({
 			cwd: "/workbase/tasks/example/phases/implementation/code/agency/src",
+			directory: ".",
 			opencode: true,
 		})
 
@@ -224,6 +268,7 @@ describe("work command", () => {
 
 		await harness.run({
 			cwd: "/workbase/tasks/example/code/agency/src",
+			directory: ".",
 			opencode: true,
 		})
 
@@ -231,7 +276,7 @@ describe("work command", () => {
 		expect(harness.launches[0]?.cwd).toBe("/workbase/tasks/example")
 	})
 
-	test("selects a target with fzf outside an entity directory", async () => {
+	test("selects a target with fzf when no directory is provided", async () => {
 		const phase = {
 			taskId: "delivery",
 			id: "build",
@@ -254,7 +299,7 @@ describe("work command", () => {
 				choices.find((choice) => choice.label.includes("build"))!.target,
 			)
 
-		await harness.run({ cwd: "/workbase", opencode: true }, pick)
+		await harness.run({ cwd: "/workbase/tasks/example", opencode: true }, pick)
 
 		expect(harness.events).toEqual([
 			"probe:fzf",
@@ -448,7 +493,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching opencode in /workbase/tasks/example",
+			"Launching command: opencode --continue (cwd: /workbase/tasks/example)",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 

package/src/commands/work.ts

@@ -23,6 +23,7 @@ import {
 } from "../workbase/workbase-choice"
 
 interface WorkOptions extends BaseCommandOptions {
+	readonly directory?: string
 	readonly taskId?: string
 	readonly phaseId?: string
 	readonly epicId?: string
@@ -32,6 +33,15 @@ interface WorkOptions extends BaseCommandOptions {
 
 type LaunchAgent = (cli: string, args: readonly string[], cwd: string) => void
 
+const formatCommand = (args: readonly string[]) =>
+	args
+		.map((argument) =>
+			/^[A-Za-z0-9_./:=+@%-]+$/.test(argument)
+				? argument
+				: `'${argument.replaceAll("'", `'\\''`)}'`,
+		)
+		.join(" ")
+
 const launchAgent: LaunchAgent = (cli, args, cwd) => {
 	process.chdir(cwd)
 	execvp(cli, [...args])
@@ -50,9 +60,12 @@ export const work = (
 				new Error("Cannot use both --opencode and --claude"),
 			)
 		}
-		if (options.epicId && (options.taskId || options.phaseId)) {
+		if (
+			options.epicId &&
+			(options.directory || options.taskId || options.phaseId)
+		) {
 			return yield* Effect.fail(
-				new Error("Cannot combine --epic with a task or phase ID"),
+				new Error("Cannot combine --epic with a directory, task, or phase ID"),
 			)
 		}
 
@@ -64,7 +77,14 @@ export const work = (
 		const phases = yield* PhaseService
 		const { log, verboseLog } = createLoggers(options)
 		const cwd = options.cwd ?? process.cwd()
-		const root = yield* resolveWorkbase(cwd, log, pickBase)
+		const directoryPath = options.directory
+			? resolve(cwd, options.directory)
+			: undefined
+		const isDirectory = directoryPath
+			? yield* fs.isDirectory(directoryPath)
+			: false
+		const startPath = isDirectory && directoryPath ? directoryPath : cwd
+		const root = yield* resolveWorkbase(startPath, log, pickBase)
 		if (!root) return
 
 		let target: WorkTarget | null = null
@@ -89,8 +109,16 @@ export const work = (
 					multiPhase: "phases" in task.data,
 				}
 			}
-		} else {
-			const path = relative(root, resolve(cwd))
+		} else if (options.directory && !isDirectory) {
+			const task = yield* tasks.show(options.directory, root)
+			target = {
+				kind: "task",
+				taskId: task.id,
+				path: task.path,
+				multiPhase: "phases" in task.data,
+			}
+		} else if (directoryPath) {
+			const path = relative(root, startPath)
 			const parts =
 				!path || isAbsolute(path) || path.startsWith(`..${sep}`)
 					? []
@@ -145,7 +173,7 @@ export const work = (
 				for (const choice of choices) log(choice.label)
 				return yield* Effect.fail(
 					new Error(
-						"fzf is required to select a work target; install fzf or provide a target explicitly",
+						"fzf is required to select a work target; install fzf or provide a directory explicitly",
 					),
 				)
 			}
@@ -199,16 +227,19 @@ export const work = (
 			yield* tasks.setStatus(target.taskId, "working", root)
 		}
 
-		verboseLog(`Launching ${cli} in ${launchPath}`)
 		const args = cli === "opencode" ? ["--continue"] : [prompt]
+		verboseLog(
+			`Launching command: ${formatCommand([cli, ...args])} (cwd: ${launchPath})`,
+		)
 		launch(cli, [cli, ...args], launchPath)
 	})
 
 export const help = `
-Usage: agency work [<task-id> [phase-id] | --epic <epic-id>]
+Usage: agency work [<directory-or-task-id> | --epic <epic-id>]
 
-Launch an agent for the current epic, task, or phase. Outside an entity
-directory, select one with fzf. Outside a workbase, select a registered
+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
+ID. Use '.' for the current directory. Outside a workbase, select a registered
 workbase first.
 
 Options:

package/src/services/WorkbaseService.test.ts

@@ -52,7 +52,7 @@ describe("WorkbaseService", () => {
 			managedWorkbaseAgents,
 		)
 		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
-			managedWorkbaseOpencode,
+			managedWorkbaseOpencode(root),
 		)
 	})
 
@@ -127,7 +127,7 @@ describe("WorkbaseService", () => {
 		)
 
 		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
-			managedWorkbaseOpencode,
+			managedWorkbaseOpencode(root),
 		)
 	})
 

package/src/services/WorkbaseService.ts

@@ -142,19 +142,17 @@ const ensureWorkbaseOpencode = (root: string) =>
 		const fs = yield* FileSystemService
 		const directory = join(root, ".opencode")
 		const path = join(directory, "opencode.jsonc")
+		const managed = managedWorkbaseOpencode(root)
 		if (!(yield* fs.exists(path))) {
 			if (yield* fs.exists(join(directory, "opencode.json"))) return
 			yield* fs.createDirectory(directory)
-			yield* fs.writeFile(path, managedWorkbaseOpencode)
+			yield* fs.writeFile(path, managed)
 			return
 		}
 
 		const content = yield* fs.readFile(path)
-		if (
-			content !== managedWorkbaseOpencode &&
-			canUpdateManagedWorkbaseOpencode(content)
-		) {
-			yield* fs.writeFile(path, managedWorkbaseOpencode)
+		if (content !== managed && canUpdateManagedWorkbaseOpencode(content)) {
+			yield* fs.writeFile(path, managed)
 		}
 	})
 

package/src/services/WorktreeService.test.ts

@@ -85,6 +85,51 @@ describe("WorktreeService", () => {
 		expect(new TextDecoder().decode(branch.stdout).trim()).toBe("task/example")
 	})
 
+	test("does not fetch origins for existing worktrees", async () => {
+		await runTestEffect(
+			TaskService.pipe(
+				Effect.flatMap((service) =>
+					service.create(
+						{
+							id: "existing",
+							ticketUrl: "https://example.com/task",
+							repo: "agency",
+							repos: [{ repo: "effect", ref: "main" }],
+							branch: "task/existing",
+							base: "main",
+						},
+						root,
+					),
+				),
+			),
+		)
+		await runTestEffect(
+			WorktreeService.pipe(
+				Effect.flatMap((service) =>
+					service.materialize("existing", undefined, root),
+				),
+			),
+		)
+		await git(
+			["remote", "set-url", "origin", join(root, "missing")],
+			join(root, "repos/agency"),
+		)
+		await git(
+			["remote", "set-url", "origin", join(root, "missing")],
+			join(root, "repos/effect"),
+		)
+
+		await expect(
+			runTestEffect(
+				WorktreeService.pipe(
+					Effect.flatMap((service) =>
+						service.materialize("existing", undefined, root),
+					),
+				),
+			),
+		).resolves.toMatchObject({ repo: "agency" })
+	})
+
 	test("uses a configured worktree creation command", async () => {
 		await Bun.write(
 			join(root, "agency.json"),

package/src/services/WorktreeService.ts

@@ -136,11 +136,13 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 							})
 						}
 
-						const remote = yield* fs.runCommand(
-							["git", "-C", repositoryPath, "remote", "get-url", "origin"],
-							{ captureOutput: true },
-						)
-						if (remote.exitCode === 0) {
+						const fetchOrigin = Effect.gen(function* () {
+							const remote = yield* fs.runCommand(
+								["git", "-C", repositoryPath, "remote", "get-url", "origin"],
+								{ captureOutput: true },
+							)
+							if (remote.exitCode !== 0) return
+
 							const fetch = yield* fs.runCommand(
 								["git", "-C", repositoryPath, "fetch", "origin"],
 								{ captureOutput: true },
@@ -150,7 +152,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Failed to fetch '${alias}': ${fetch.stderr}`,
 								})
 							}
-						}
+						})
 
 						const listed = yield* fs.runCommand(
 							[
@@ -208,6 +210,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Worktree registry contains a missing checkout at ${checkoutPath}`,
 								})
 							}
+							yield* fetchOrigin
 
 							let args: string[]
 							let env: Record<string, string> | undefined
@@ -341,6 +344,7 @@ export class WorktreeService extends Effect.Service<WorktreeService>()(
 									message: `Worktree registry contains a missing checkout at ${checkoutPath}`,
 								})
 							}
+							yield* fetchOrigin
 							const result = yield* fs.runCommand(
 								[
 									"git",

package/src/workbase/opencode-file.ts

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto"
+import { join } from "node:path"
 
 const managedHeaderPattern =
 	/^\/\/ agency-managed: sha256=([a-f0-9]{64})\r?\n\r?\n/
@@ -6,28 +7,36 @@ const managedHeaderPattern =
 const checksum = (content: string) =>
 	createHash("sha256").update(content).digest("hex")
 
-const body = `${JSON.stringify(
-	{
-		$schema: "https://opencode.ai/config.json",
-		references: {
-			tasks: {
-				path: "../tasks",
-				description: "Agency task definitions and execution context",
+const body = (root: string) =>
+	`${JSON.stringify(
+		{
+			$schema: "https://opencode.ai/config.json",
+			references: {
+				tasks: {
+					path: "../tasks",
+					description: "Agency task definitions and execution context",
+				},
+				epics: {
+					path: "../epics",
+					description: "Agency epic definitions and orchestration context",
+				},
 			},
-			epics: {
-				path: "../epics",
-				description: "Agency epic definitions and orchestration context",
+			permission: {
+				external_directory: {
+					[`${join(root, "tasks")}/*`]: "allow",
+					[`${join(root, "epics")}/*`]: "allow",
+				},
 			},
 		},
-	},
-	null,
-	2,
-)}\n`
+		null,
+		2,
+	)}\n`
 
-const renderManagedWorkbaseOpencode = (content: string = body) =>
+const renderManagedWorkbaseOpencode = (content: string) =>
 	`// agency-managed: sha256=${checksum(content)}\n\n${content}`
 
-export const managedWorkbaseOpencode = renderManagedWorkbaseOpencode()
+export const managedWorkbaseOpencode = (root: string) =>
+	renderManagedWorkbaseOpencode(body(root))
 
 export const canUpdateManagedWorkbaseOpencode = (content: string) => {
 	const match = content.match(managedHeaderPattern)