@markjaquith/agency 3.2.14 → 3.2.15

package/src/cli.test.ts

@@ -1,1889 +0,0 @@
-import {
-	afterAll,
-	afterEach,
-	describe,
-	expect,
-	setDefaultTimeout,
-	test,
-} from "bun:test"
-import { access, chmod, mkdir, realpath, stat, symlink } from "node:fs/promises"
-import { join, sep } from "node:path"
-import errorFixture from "../fixtures/protocol/error.json"
-import successFixture from "../fixtures/protocol/success.json"
-import { cleanupTempDir, createTempDir } from "./test-utils"
-
-const projectRoot = join(import.meta.dir, "..")
-const cliPath = join(projectRoot, "cli.ts")
-const isolatedConfigHome = await createTempDir()
-
-setDefaultTimeout(15_000)
-
-afterAll(() => cleanupTempDir(isolatedConfigHome))
-
-interface CliResult {
-	exitCode: number
-	stdout: string
-	stderr: string
-}
-
-async function runCli(
-	args: string[],
-	cwd = projectRoot,
-	env?: Record<string, string>,
-): Promise<CliResult> {
-	const subprocess = Bun.spawn([process.execPath, cliPath, ...args], {
-		cwd,
-		env: {
-			...process.env,
-			XDG_CONFIG_HOME: isolatedConfigHome,
-			XDG_STATE_HOME: isolatedConfigHome,
-			AGENCY_NO_USAGE_LOG: "1",
-			...env,
-		},
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const [exitCode, stdout, stderr] = await Promise.all([
-		subprocess.exited,
-		new Response(subprocess.stdout).text(),
-		new Response(subprocess.stderr).text(),
-	])
-	return { exitCode, stdout, stderr }
-}
-
-function parseJson(result: CliResult) {
-	expect(result.exitCode, JSON.stringify(result)).toBe(0)
-	expect(result.stderr).toBe("")
-	const envelope = JSON.parse(result.stdout)
-	expect(envelope).toMatchObject({ version: 1, ok: true })
-	return envelope.result
-}
-
-async function runGit(args: string[]) {
-	const subprocess = Bun.spawn(["git", ...args], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const [exitCode, stdout, stderr] = await Promise.all([
-		subprocess.exited,
-		new Response(subprocess.stdout).text(),
-		new Response(subprocess.stderr).text(),
-	])
-	if (exitCode !== 0) throw new Error(stderr)
-	return stdout
-}
-
-async function startGitDaemon(basePath: string) {
-	const port = 20000 + Math.floor(Math.random() * 20000)
-	const process = Bun.spawn(
-		[
-			"git",
-			"daemon",
-			"--reuseaddr",
-			"--export-all",
-			`--base-path=${basePath}`,
-			"--listen=127.0.0.1",
-			`--port=${port}`,
-			basePath,
-		],
-		{ stdout: "pipe", stderr: "pipe" },
-	)
-	const remote = `git://127.0.0.1:${port}/source.git`
-	for (let attempt = 0; attempt < 40; attempt++) {
-		const probe = Bun.spawn(["git", "ls-remote", remote], {
-			stdout: "ignore",
-			stderr: "ignore",
-		})
-		if ((await probe.exited) === 0) return { process, remote }
-		await Bun.sleep(25)
-	}
-	process.kill()
-	throw new Error("Git daemon did not start")
-}
-
-describe("CLI", () => {
-	const tempDirs: string[] = []
-	const daemons: Bun.Subprocess[] = []
-
-	afterEach(async () => {
-		await Promise.all(
-			daemons.splice(0).map(async (daemon) => {
-				daemon.kill()
-				await daemon.exited
-			}),
-		)
-		await Promise.all(tempDirs.splice(0).map(cleanupTempDir))
-	})
-
-	test("reports version and routes top-level help with intentional statuses", async () => {
-		const version = await runCli(["--version"])
-		expect(version).toEqual({
-			exitCode: 0,
-			stdout: "v0.0.0-development\n",
-			stderr: "",
-		})
-
-		const noArgs = await runCli([])
-		expect(noArgs.exitCode).toBe(1)
-		expect(noArgs.stdout).toContain("Usage: agency <command> [options]")
-		expect(noArgs.stderr).toBe("")
-
-		const help = await runCli(["--help"])
-		expect(help.exitCode).toBe(0)
-		expect(help.stdout).toContain("Usage: agency <command> [options]")
-		expect(help.stderr).toBe("")
-	})
-
-	test("keeps the published protocol fixtures synchronized with CLI output", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const success = await runCli(["init", root, "--json"], parent)
-		expect(success.exitCode).toBe(0)
-		expect(success.stderr).toBe("")
-		expect(success.stdout.endsWith("\n")).toBe(true)
-		const successEnvelope = JSON.parse(success.stdout)
-		expect(successEnvelope.result.root).toBe(root)
-		expect({
-			...successEnvelope,
-			result: { ...successEnvelope.result, root: "/work/agency" },
-		}).toEqual(successFixture)
-
-		const failure = await runCli(["unknown", "--json"])
-		expect(failure.exitCode).toBe(1)
-		expect(failure.stderr).toBe("")
-		expect(failure.stdout.endsWith("\n")).toBe(true)
-		expect(JSON.parse(failure.stdout)).toEqual(errorFixture)
-	})
-
-	test("reports unknown commands and preserves tagged error messages", async () => {
-		const unknown = await runCli(["unknown"])
-		expect(unknown.exitCode).toBe(1)
-		expect(unknown.stdout).toBe("")
-		expect(unknown.stderr).toContain("Unknown command 'unknown'")
-		expect(unknown.stderr).toContain("Usage: agency <command> [options]")
-
-		const cwd = await createTempDir()
-		tempDirs.push(cwd)
-		const taggedError = await runCli(["repo", "list"], cwd)
-		expect(taggedError.exitCode).toBe(1)
-		expect(taggedError.stdout).toBe("")
-		expect(taggedError.stderr).toContain("ⓘ No Agency workbase found from")
-		expect(taggedError.stderr).not.toContain("An error has occurred")
-	})
-
-	test("records successful and failed invocations without argument values", async () => {
-		const state = await createTempDir()
-		tempDirs.push(state)
-		const env = {
-			XDG_STATE_HOME: state,
-			AGENCY_SESSION_ID: "cli-session",
-			AGENCY_NO_USAGE_LOG: "0",
-			AGENCY_INVOCATION_SOURCE: "automation",
-			AGENCY_USAGE_TEST: "1",
-		}
-		expect((await runCli(["--version"], projectRoot, env)).exitCode).toBe(0)
-		expect(
-			(
-				await runCli(
-					[
-						"task",
-						"create",
-						"private-customer-id",
-						"--repo",
-						"private-repository",
-						"--description",
-						"private free-form input",
-						"--cwd",
-						"/private/customer/path",
-					],
-					projectRoot,
-					env,
-				)
-			).exitCode,
-		).toBe(1)
-		expect(
-			(await runCli(["unknown", "--private-flag=value"], projectRoot, env))
-				.exitCode,
-		).toBe(1)
-
-		const exported = await runCli(["usage", "export"], projectRoot, env)
-		expect(exported).toMatchObject({ exitCode: 0, stderr: "" })
-		const events = exported.stdout
-			.trim()
-			.split("\n")
-			.map((line) => JSON.parse(line))
-		expect(events).toEqual([
-			expect.objectContaining({
-				journeyId: expect.stringMatching(/^sha256:[a-f0-9]{64}$/),
-				journeySequence: 1,
-				invocationSource: "automation",
-				isTest: true,
-				commandPath: "version",
-				flagNames: ["version"],
-				outcome: "success",
-				outcomeCode: "SUCCESS",
-			}),
-			expect.objectContaining({
-				journeySequence: 2,
-				commandPath: "task/create",
-				flagNames: ["cwd", "description", "repo"],
-				outcome: "failure",
-				outcomeCode: "WORKBASE_NOT_FOUND",
-			}),
-			expect.objectContaining({
-				journeySequence: 3,
-				commandPath: "invalid",
-				flagNames: [],
-				outcome: "failure",
-				outcomeCode: "CLI_USAGE",
-			}),
-		])
-		for (const value of [
-			"cli-session",
-			"private-customer-id",
-			"private-repository",
-			"private free-form input",
-			"/private/customer/path",
-			"private-flag",
-			"value",
-		]) {
-			expect(exported.stdout).not.toContain(value)
-		}
-	})
-
-	test("records status-based non-PR completion", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos", "agency"), { recursive: true })
-		parseJson(
-			await runCli(
-				["task", "create", "non-pr", "--repo", "agency", "--json"],
-				root,
-			),
-		)
-		parseJson(
-			await runCli(
-				[
-					"task",
-					"status",
-					"non-pr",
-					"done",
-					"--no-pull-request",
-					"--summary",
-					"Investigation completed without changes.",
-					"--evidence-url",
-					"https://example.com/result",
-					"--json",
-				],
-				root,
-			),
-		)
-		expect(
-			parseJson(await runCli(["task", "show", "non-pr", "--json"], root)).data,
-		).toMatchObject({
-			status: "done",
-			completion: {
-				mode: "non-pr",
-				summary: "Investigation completed without changes.",
-				evidenceUrl: "https://example.com/result",
-			},
-		})
-		const prUpdate = await runCli(
-			[
-				"task",
-				"update",
-				"non-pr",
-				"--pr-url",
-				"https://github.com/example/agency/pull/1",
-			],
-			root,
-		)
-		expect(prUpdate.exitCode).toBe(1)
-		expect(prUpdate.stderr).toContain("Reopen non-PR completed work")
-	})
-
-	test("routes graph mutations through structured output", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos", "agency"), { recursive: true })
-		parseJson(
-			await runCli(
-				[
-					"epic",
-					"create",
-					"delivery",
-					"--ticket-url",
-					"https://example.com/delivery",
-					"--repo",
-					"agency:main",
-					"--json",
-				],
-				root,
-			),
-		)
-		for (const id of ["first", "second"]) {
-			parseJson(
-				await runCli(
-					[
-						"task",
-						"create",
-						id,
-						"--repo",
-						"agency",
-						"--epic",
-						"delivery",
-						"--json",
-					],
-					root,
-				),
-			)
-		}
-		const observed = parseJson(
-			await runCli(["task", "show", "second", "--json"], root),
-		)
-		const taskPath = join(root, "tasks/second/TASK.md")
-		await Bun.write(
-			taskPath,
-			`${await Bun.file(taskPath).text()}\nConcurrent edit.\n`,
-		)
-		const conflict = await runCli(
-			[
-				"task",
-				"update",
-				"second",
-				"--description",
-				"Stale update",
-				"--if-revision",
-				observed.revision,
-				"--json",
-			],
-			root,
-		)
-		expect(conflict.exitCode).toBe(1)
-		expect(JSON.parse(conflict.stdout)).toMatchObject({
-			ok: false,
-			error: {
-				code: "REVISION_CONFLICT",
-				retryable: true,
-				fields: {
-					path: "tasks/second/TASK.md",
-					expectedRevision: observed.revision,
-					currentRevision: expect.stringMatching(/^[a-f0-9]{64}$/),
-				},
-			},
-		})
-		expect(await Bun.file(taskPath).text()).toContain("Concurrent edit.")
-
-		const updated = parseJson(
-			await runCli(
-				["task", "update", "second", "--description", "Revised", "--json"],
-				root,
-			),
-		)
-		expect(updated).toMatchObject({
-			operation: "task.update",
-			entity: { kind: "task", id: "second" },
-			validation: { valid: true, scope: ["tasks/second/TASK.md"] },
-		})
-
-		const dependency = parseJson(
-			await runCli(
-				["task", "dependency", "add", "second", "first", "--json"],
-				root,
-			),
-		)
-		expect(dependency).toMatchObject({
-			operation: "task.dependency.add",
-			changedPaths: ["epics/delivery/EPIC.md"],
-		})
-	})
-
-	test("emits one versioned error envelope for usage and command failures", async () => {
-		const usage = await runCli(["unknown", "--json"])
-		expect(usage.exitCode).toBe(1)
-		expect(usage.stderr).toBe("")
-		expect(usage.stdout.trim().split("\n")).toHaveLength(1)
-		expect(JSON.parse(usage.stdout)).toEqual({
-			version: 1,
-			ok: false,
-			error: {
-				code: "CLI_USAGE",
-				message:
-					"Unknown command 'unknown'.\n\nUsage: agency <command> [options]",
-				fields: {
-					detail: "Unknown command 'unknown'.",
-					usage: "agency <command> [options]",
-				},
-				retryable: false,
-				remediation:
-					"Correct the arguments using the usage value in error.fields.",
-			},
-		})
-
-		const cwd = await createTempDir()
-		tempDirs.push(cwd)
-		const commandFailure = await runCli(
-			["repo", "list", "--json", "--silent"],
-			cwd,
-		)
-		expect(commandFailure.exitCode).toBe(1)
-		expect(commandFailure.stderr).toBe("")
-		expect(JSON.parse(commandFailure.stdout)).toMatchObject({
-			version: 1,
-			ok: false,
-			error: {
-				code: "WORKBASE_NOT_FOUND",
-				retryable: false,
-			},
-		})
-	})
-
-	test("preserves the JSON error contract when archiving an already archived task", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		expect(
-			Bun.spawnSync(["git", "init", "--bare", join(root, "repos/agency")])
-				.exitCode,
-		).toBe(0)
-		await mkdir(join(root, "tasks/example"), { recursive: true })
-		await Bun.write(
-			join(root, "tasks/example/TASK.md"),
-			`---
-ticketUrl: null
-repo: agency
-branch: task/example
-base: main
-pr: null
-status: dropped
----
-
-# Example
-`,
-		)
-
-		expect(
-			(await runCli(["archive", "."], join(root, "tasks/example"))).exitCode,
-		).toBe(0)
-		const result = await runCli(["archive", "task", "example", "--json"], root)
-
-		expect(result.exitCode).toBe(1)
-		expect(result.stderr).toBe("")
-		expect(JSON.parse(result.stdout)).toEqual({
-			version: 1,
-			ok: false,
-			error: {
-				code: "TASK_ERROR",
-				message: "Task 'example' is already archived",
-				fields: {},
-				retryable: false,
-			},
-		})
-	})
-
-	test("rejects malformed input before running a command", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const result = await runCli(["init", root, "extra"])
-
-		expect(result.exitCode).toBe(1)
-		expect(result.stderr).toContain("Usage: agency init [path] [--json]")
-		await expect(access(root)).rejects.toThrow()
-	})
-
-	test("resolves relative init paths from explicit cwd", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const result = parseJson(
-			await runCli(["init", "child", "--cwd", parent, "--json"], projectRoot),
-		)
-		expect(result.root).toBe(join(parent, "child"))
-	})
-
-	test("refuses guided input without a TTY or with --no-input", async () => {
-		for (const args of [
-			["task", "new"],
-			["task", "new", "example", "--no-input"],
-		]) {
-			const result = await runCli(args)
-			expect(result.exitCode).toBe(1)
-			expect(result.stderr).toContain("task new requires interactive input")
-			expect(result.stderr).toContain("agency task create")
-		}
-		const actResult = await runCli(["act", "--no-input"])
-		expect(actResult.exitCode).toBe(1)
-		expect(actResult.stderr).toContain("agency act requires interactive input")
-	})
-
-	test("routes command help and global options on either side of commands", async () => {
-		const commands = [
-			["act", "Usage: agency act"],
-			["init", "Usage: agency init"],
-			["workbase", "Usage: agency workbase"],
-			["integration", "Usage: agency integration"],
-			["repo", "Usage: agency repo"],
-			["epic", "Usage: agency epic"],
-			["task", "Usage: agency task"],
-			["phase", "Usage: agency phase"],
-			["archive", "Usage: agency archive"],
-			["restore", "Usage: agency restore"],
-			["work", "Usage: agency work"],
-			["push", "Usage: agency push"],
-			["pr", "Work with GitHub pull requests."],
-			["status", "Usage: agency status"],
-			["validate", "Usage: agency validate"],
-			["context", "Usage: agency context"],
-			["graph", "Usage: agency graph"],
-			["next", "Usage: agency next"],
-		] as const
-		for (let offset = 0; offset < commands.length; offset += 4) {
-			const results = await Promise.all(
-				commands.slice(offset, offset + 4).map(async ([command, usage]) => ({
-					usage,
-					result: await runCli([command, "--help"]),
-				})),
-			)
-			for (const { result, usage } of results) {
-				expect(result.exitCode).toBe(0)
-				expect(result.stdout).toContain(usage)
-				expect(result.stderr).toBe("")
-			}
-		}
-
-		const helpBefore = await runCli(["--help", "task"])
-		expect(helpBefore.exitCode).toBe(0)
-		expect(helpBefore.stdout).toContain("Usage: agency task <subcommand>")
-		expect(helpBefore.stderr).toBe("")
-
-		const root = await createTempDir()
-		tempDirs.push(root)
-		const before = await runCli(["--silent", "init", root])
-		expect(before).toEqual({ exitCode: 0, stdout: "", stderr: "" })
-
-		const after = await runCli(["status", "--silent"], root)
-		expect(after).toEqual({ exitCode: 0, stdout: "", stderr: "" })
-	}, 30_000)
-
-	test("passes pr arguments and exit status through to gh", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		const bin = join(root, "bin")
-		const capture = join(root, "capture")
-		await mkdir(bin)
-		await Bun.write(
-			join(bin, "gh"),
-			`#!/bin/sh
-printf '%s\n' "$PWD" "$@" > "$GH_CAPTURE"
-exit 23
-`,
-		)
-		await chmod(join(bin, "gh"), 0o755)
-		const args = ["pr", "create", "--title", "two words", "--", "literal"]
-
-		const result = await runCli(args, root, {
-			PATH: `${bin}:${process.env.PATH ?? ""}`,
-			GH_CAPTURE: capture,
-		})
-
-		expect(result).toEqual({ exitCode: 23, stdout: "", stderr: "" })
-		expect((await Bun.file(capture).text()).trim().split("\n")).toEqual([
-			await realpath(root),
-			...args,
-		])
-	})
-
-	test("lists ready work and exposes excluded blockers through one result", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		await Bun.write(join(root, "agency.json"), '{"version":2}\n')
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		for (const id of ["ready", "finished"]) {
-			parseJson(
-				await runCli(
-					["task", "create", id, "--repo", "agency", "--json"],
-					root,
-				),
-			)
-		}
-		parseJson(
-			await runCli(["task", "status", "finished", "dropped", "--json"], root),
-		)
-
-		const human = await runCli(["next"], root)
-		expect(human).toMatchObject({ exitCode: 0, stderr: "" })
-		expect(human.stdout).toContain("1. task/ready")
-		expect(human.stdout).not.toContain("task/finished")
-
-		const result = parseJson(await runCli(["next", "--select", "--json"], root))
-		expect(result.selected).toMatchObject({ key: "task/ready", rank: 1 })
-		expect(result.ready.map((item: any) => item.key)).toEqual(["task/ready"])
-		expect(result.excluded).toMatchObject([
-			{
-				key: "task/finished",
-				status: "dropped",
-				terminal: true,
-				blockers: [{ kind: "status", reason: "Task status is dropped" }],
-			},
-		])
-
-		const blockedPr = await runCli(["pr", "create", "finished", "--json"], root)
-		expect(blockedPr.exitCode).toBe(1)
-		expect(blockedPr.stderr).toBe("")
-		expect(JSON.parse(blockedPr.stdout)).toMatchObject({
-			ok: false,
-			error: {
-				code: "EXECUTION_BLOCKED",
-				fields: {
-					status: "dropped",
-					blockers: [{ kind: "status", reason: "Task status is dropped" }],
-				},
-			},
-		})
-	})
-
-	test("reports and synchronizes managed integration files", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		expect((await runCli(["init", root])).exitCode).toBe(0)
-
-		const before = parseJson(
-			await runCli(["integration", "status", "--json"], root),
-		)
-		expect(before.files).toMatchObject([
-			{ name: "agents", state: "managed" },
-			{ name: "opencode", state: "managed" },
-			{ name: "opencode-plugin", state: "managed" },
-			{ name: "opencode-tui", state: "managed" },
-			{ name: "opencode-tui-plugin", state: "managed" },
-		])
-
-		const synced = parseJson(
-			await runCli(["integration", "sync", "--json"], root),
-		)
-		expect(synced.files).toMatchObject([
-			{ name: "agents", state: "managed", changed: false },
-			{ name: "opencode", state: "managed", changed: false },
-			{ name: "opencode-plugin", state: "managed", changed: false },
-			{ name: "opencode-tui", state: "managed", changed: false },
-			{ name: "opencode-tui-plugin", state: "managed", changed: false },
-		])
-	})
-
-	test("registers and lists workbases", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const env = { XDG_CONFIG_HOME: join(parent, "config") }
-
-		expect(
-			parseJson(await runCli(["init", root, "--json"], parent, env)),
-		).toEqual({
-			root,
-		})
-		const registration = parseJson(
-			await runCli(
-				[
-					"workbase",
-					"add",
-					"workbase",
-					"--cwd",
-					parent,
-					"--name",
-					"primary",
-					"--json",
-				],
-				projectRoot,
-				env,
-			),
-		)
-		expect(registration).toMatchObject({
-			name: "primary",
-			path: await realpath(root),
-		})
-		expect(
-			parseJson(await runCli(["workbase", "list", "--json"], parent, env)),
-		).toEqual({ workbases: [registration] })
-
-		await mkdir(join(root, "repos", "agency"), { recursive: true })
-		parseJson(
-			await runCli(
-				[
-					"task",
-					"create",
-					"explicit",
-					"--repo",
-					"agency",
-					"--workbase",
-					"primary",
-					"--no-input",
-					"--json",
-				],
-				parent,
-				env,
-			),
-		)
-		const shown = parseJson(
-			await runCli(
-				[
-					"task",
-					"show",
-					"--task",
-					"explicit",
-					"--workbase",
-					registration.id,
-					"--no-input",
-					"--json",
-				],
-				parent,
-				env,
-			),
-		)
-		expect(shown.id).toBe("explicit")
-		const inferred = parseJson(
-			await runCli(
-				["context", "--cwd", join(root, "tasks", "explicit"), "--json"],
-				projectRoot,
-				env,
-			),
-		)
-		expect(inferred.target).toMatchObject({
-			kind: "task",
-			taskId: "explicit",
-		})
-		const nextByCwd = parseJson(
-			await runCli(
-				["next", "--cwd", root, "--select", "--json"],
-				projectRoot,
-				env,
-			),
-		)
-		expect(nextByCwd.selected.key).toBe("task/explicit")
-		const nextByRegistration = parseJson(
-			await runCli(
-				["next", "--workbase", "primary", "--select", "--json"],
-				projectRoot,
-				env,
-			),
-		)
-		expect(nextByRegistration.selected.key).toBe("task/explicit")
-
-		parseJson(
-			await runCli(["workbase", "default", "primary", "--json"], parent, env),
-		)
-		expect(
-			parseJson(await runCli(["task", "list", "--json"], parent, env)),
-		).toHaveLength(1)
-		const explicitOutside = await runCli(
-			["task", "list", "--cwd", parent, "--json"],
-			projectRoot,
-			env,
-		)
-		expect(explicitOutside.exitCode).toBe(1)
-		expect(explicitOutside.stderr).toBe("")
-		expect(JSON.parse(explicitOutside.stdout).error.message).toContain(
-			"No Agency workbase found from",
-		)
-	}, 20_000)
-
-	test("exports equivalent JSON and JSONL graph contracts", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		expect((await runCli(["init", root])).exitCode).toBe(0)
-		await mkdir(join(root, "repos/agency"), { recursive: true })
-		await mkdir(join(root, "tasks/example"), { recursive: true })
-		await Bun.write(
-			join(root, "tasks/example/TASK.md"),
-			`---
-ticketUrl: null
-repo: agency
-branch: feat/example
-base: main
-pr: null
-status: open
----
-
-# Example
-`,
-		)
-
-		const json = parseJson(
-			await runCli(
-				["graph", "--json", "--include", "bodies", "--kind", "task"],
-				root,
-			),
-		)
-		expect(json).toMatchObject({
-			version: 1,
-			includes: ["bodies"],
-			nodes: [
-				{ id: "task:example", body: expect.stringContaining("# Example") },
-			],
-			edges: [],
-		})
-
-		const streamed = await runCli(
-			["graph", "--jsonl", "--include", "bodies", "--kind", "task"],
-			root,
-		)
-		expect(streamed.exitCode).toBe(0)
-		expect(streamed.stderr).toBe("")
-		const records = streamed.stdout
-			.trim()
-			.split("\n")
-			.map((line) => JSON.parse(line))
-		expect(records.map((record) => record.type)).toEqual([
-			"meta",
-			"node",
-			"end",
-		])
-		const reconstructed = {
-			...records[0].graph,
-			nodes: records
-				.filter((record) => record.type === "node")
-				.map((record) => record.node),
-			edges: records
-				.filter((record) => record.type === "edge")
-				.map((record) => record.edge),
-		}
-		expect(reconstructed).toEqual(json)
-	})
-
-	test("lets JSON override silent and disables interactive task input", async () => {
-		const root = await createTempDir()
-		tempDirs.push(root)
-		const result = await runCli(["init", root, "--json", "--silent"])
-		expect(parseJson(result)).toEqual({ root })
-
-		const interactive = await runCli(["task", "new", "--json"])
-		expect(interactive.exitCode).toBe(1)
-		expect(interactive.stderr).toBe("")
-		expect(JSON.parse(interactive.stdout)).toMatchObject({
-			version: 1,
-			ok: false,
-			error: { code: "COMMAND_FAILED", retryable: false },
-		})
-	})
-
-	test("materializes a linked repository through the CLI", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const source = join(parent, "source")
-		await runGit(["init", "--initial-branch=main", source])
-		await Bun.write(join(source, "README.md"), "materialize\n")
-		for (const args of [
-			["config", "user.email", "test@example.com"],
-			["config", "user.name", "Test"],
-			["add", "README.md"],
-			["-c", "commit.gpgsign=false", "commit", "-m", "initial"],
-			[
-				"remote",
-				"add",
-				"origin",
-				"https://example.com/agency-tests/source.git",
-			],
-		]) {
-			await runGit(["-C", source, ...args])
-		}
-
-		parseJson(await runCli(["init", root, "--json"], parent))
-		const configPath = join(root, "agency.json")
-		await Bun.write(
-			configPath,
-			JSON.stringify({ ...(await Bun.file(configPath).json()), vcs: "git" }),
-		)
-		parseJson(await runCli(["repo", "link", "agency", source, "--json"], root))
-		const materialized = parseJson(
-			await runCli(["repo", "materialize", "agency", "--json"], root),
-		)
-
-		expect(materialized).toMatchObject({
-			alias: "agency",
-			kind: "bare",
-			target: null,
-			states: ["declared", "materialized"],
-		})
-		expect(await Bun.file(join(root, "repos/agency/HEAD")).exists()).toBe(true)
-	})
-
-	test("prepares a workspace and reports a non-mutating dry-run", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const source = join(parent, "source")
-		expect(
-			Bun.spawnSync(["git", "init", "--initial-branch=main", source]).exitCode,
-		).toBe(0)
-		await Bun.write(join(source, "README.md"), "example\n")
-		for (const args of [
-			["config", "user.email", "test@example.com"],
-			["config", "user.name", "Test"],
-			["add", "README.md"],
-			["-c", "commit.gpgsign=false", "commit", "-m", "initial"],
-			["remote", "add", "origin", source],
-		]) {
-			expect(Bun.spawnSync(["git", "-C", source, ...args]).exitCode).toBe(0)
-		}
-
-		parseJson(await runCli(["init", root, "--json"], parent))
-		await Bun.write(
-			join(root, "agency.json"),
-			JSON.stringify({
-				version: 2,
-				repositories: {
-					agency: {
-						remote: "https://example.com/agency-tests/source.git",
-					},
-				},
-			}),
-		)
-		parseJson(await runCli(["repo", "link", "agency", source, "--json"], root))
-		parseJson(
-			await runCli(
-				[
-					"task",
-					"create",
-					"example",
-					"--repo",
-					"agency",
-					"--branch",
-					"feat/example",
-					"--base",
-					"main",
-					"--json",
-				],
-				root,
-			),
-		)
-
-		const planned = parseJson(
-			await runCli(["work", "prepare", "example", "--dry-run", "--json"], root),
-		)
-		const workbaseRoot = await realpath(root)
-		expect(planned).toMatchObject({
-			dryRun: true,
-			taskPath: join(workbaseRoot, "tasks/example/TASK.md"),
-			phasePath: null,
-			checkouts: [
-				{
-					repo: "agency",
-					kind: "writable",
-					action: "created",
-					resolvedCommit: expect.stringMatching(/^[0-9a-f]{40}$/),
-				},
-			],
-		})
-		await expect(access(join(root, "tasks/example/code"))).rejects.toThrow()
-
-		const prepared = parseJson(
-			await runCli(["work", "prepare", "example", "--json"], root),
-		)
-		expect(prepared).toMatchObject({
-			dryRun: false,
-			checkouts: [{ action: "created", kind: "writable" }],
-		})
-		const task = parseJson(
-			await runCli(["task", "show", "example", "--json"], root),
-		)
-		expect(task.data.status).toBe("open")
-
-		const listed = parseJson(await runCli(["worktree", "list", "--json"], root))
-		expect(listed).toEqual([
-			expect.objectContaining({
-				owner: expect.objectContaining({ kind: "task", taskId: "example" }),
-				checkouts: [
-					expect.objectContaining({
-						repo: "agency",
-						kind: "writable",
-						registered: true,
-						actualBranch: "feat/example",
-						actualCommit: expect.stringMatching(/^[0-9a-f]{40}$/),
-						dirty: false,
-					}),
-				],
-			}),
-		])
-		const preparedAgain = parseJson(
-			await runCli(
-				["work", "prepare", join(root, "tasks/example/TASK.md"), "--json"],
-				parent,
-			),
-		)
-		expect(preparedAgain.checkouts).toEqual([
-			expect.objectContaining({ action: "reused", kind: "writable" }),
-		])
-		const rebuild = parseJson(
-			await runCli(
-				["worktree", "rebuild", "example", "--dry-run", "--json"],
-				root,
-			),
-		)
-		expect(rebuild).toMatchObject({
-			operation: "rebuild",
-			dryRun: true,
-			actions: [
-				`remove ${join(workbaseRoot, "tasks/example/code/agency")}`,
-				`create ${join(workbaseRoot, "tasks/example/code/agency")}`,
-			],
-		})
-		expect(
-			await Bun.file(join(root, "tasks/example/code/agency/README.md")).text(),
-		).toBe("example\n")
-	})
-
-	test.skipIf(
-		Bun.which("opencode") === null || process.env.AGENCY_TEST_OPENCODE !== "1",
-	)(
-		"provides effective whole-workbase OpenCode access from every launch topology",
-		async () => {
-			const parent = await createTempDir()
-			tempDirs.push(parent)
-			const root = join(parent, "workbase")
-			const source = join(parent, "source")
-			expect(
-				Bun.spawnSync(["git", "init", "--initial-branch=main", source])
-					.exitCode,
-			).toBe(0)
-			await Bun.write(join(source, "README.md"), "example\n")
-			await mkdir(join(source, ".claude/skills/repository-skill"), {
-				recursive: true,
-			})
-			await Bun.write(
-				join(source, ".claude/skills/repository-skill/SKILL.md"),
-				"---\nname: repository-skill\ndescription: Repository discovery test.\n---\n\nRepository skill content.\n",
-			)
-			for (const args of [
-				["config", "user.email", "test@example.com"],
-				["config", "user.name", "Test"],
-				["add", "."],
-				["-c", "commit.gpgsign=false", "commit", "-m", "initial"],
-			]) {
-				expect(Bun.spawnSync(["git", "-C", source, ...args]).exitCode).toBe(0)
-			}
-			await runGit(["clone", "--bare", source, join(parent, "source.git")])
-			const daemon = await startGitDaemon(parent)
-			daemons.push(daemon.process)
-			await runGit(["-C", source, "remote", "add", "origin", daemon.remote])
-
-			parseJson(await runCli(["init", root, "--json"], parent))
-			expect(
-				Bun.spawnSync(["git", "init", "--initial-branch=main", root]).exitCode,
-			).toBe(0)
-			const agencyConfigPath = join(root, "agency.json")
-			const agencyConfig = JSON.parse(await Bun.file(agencyConfigPath).text())
-			await Bun.write(
-				agencyConfigPath,
-				`${JSON.stringify(
-					{
-						...agencyConfig,
-						agents: { noop: { command: ["true"] } },
-					},
-					null,
-					2,
-				)}\n`,
-			)
-			parseJson(
-				await runCli(["repo", "link", "agency", source, "--json"], root),
-			)
-			parseJson(
-				await runCli(
-					[
-						"epic",
-						"create",
-						"delivery",
-						"--ticket-url",
-						"https://example.com/delivery",
-						"--repo",
-						"agency:main",
-						"--json",
-					],
-					root,
-				),
-			)
-			for (const [id, branch] of [
-				["example", "feat/example"],
-				["sibling", "feat/sibling"],
-			] as const) {
-				parseJson(
-					await runCli(
-						[
-							"task",
-							"create",
-							id,
-							"--repo",
-							"agency",
-							"--branch",
-							branch,
-							"--base",
-							"main",
-							"--epic",
-							"delivery",
-							"--json",
-						],
-						root,
-					),
-				)
-			}
-			parseJson(
-				await runCli(
-					["task", "create", "pipeline", "--multi-phase", "--json"],
-					root,
-				),
-			)
-			parseJson(
-				await runCli(
-					[
-						"phase",
-						"create",
-						"pipeline",
-						"build",
-						"--repo",
-						"agency",
-						"--branch",
-						"feat/pipeline-build",
-						"--base",
-						"main",
-						"--json",
-					],
-					root,
-				),
-			)
-
-			parseJson(await runCli(["work", "prepare", "example", "--json"], root))
-			parseJson(
-				await runCli(
-					[
-						"work",
-						"prepare",
-						"--task",
-						"pipeline",
-						"--phase",
-						"build",
-						"--json",
-					],
-					root,
-				),
-			)
-			const synced = parseJson(
-				await runCli(["integration", "sync", "--json"], root),
-			)
-			expect(
-				synced.files.every((file: { changed: boolean }) => !file.changed),
-			).toBe(true)
-
-			const workbaseRoot = await realpath(root)
-			const config = await Bun.file(
-				join(workbaseRoot, ".opencode/opencode.jsonc"),
-			).text()
-			expect(config).not.toContain(workbaseRoot)
-			const documents = [
-				join(workbaseRoot, "tasks/example/TASK.md"),
-				join(workbaseRoot, "epics/delivery/EPIC.md"),
-				join(workbaseRoot, "tasks/sibling/TASK.md"),
-			]
-			for (const document of documents) {
-				expect(await Bun.file(document).exists()).toBe(true)
-			}
-
-			const launches = [
-				{
-					args: ["--task", "example"],
-					cwd: join(workbaseRoot, "tasks/example"),
-					checkoutPath: join(workbaseRoot, "tasks/example/code/agency"),
-					skillPath: join(
-						workbaseRoot,
-						"tasks/example/code/agency/.claude/skills",
-					),
-				},
-				{
-					args: ["--task", "pipeline", "--phase", "build"],
-					cwd: join(workbaseRoot, "tasks/pipeline/phases/build"),
-					checkoutPath: join(
-						workbaseRoot,
-						"tasks/pipeline/phases/build/code/agency",
-					),
-					skillPath: join(
-						workbaseRoot,
-						"tasks/pipeline/phases/build/code/agency/.claude/skills",
-					),
-				},
-				{
-					args: ["--epic", "delivery"],
-					cwd: join(workbaseRoot, "epics/delivery"),
-					checkoutPath: undefined,
-					skillPath: undefined,
-				},
-				{
-					args: ["--task", "pipeline"],
-					cwd: join(workbaseRoot, "tasks/pipeline"),
-					checkoutPath: undefined,
-					skillPath: undefined,
-				},
-			]
-			for (const launch of launches) {
-				const printed = await runCli(
-					["work", ...launch.args, "--opencode", "--print-command", "--force"],
-					root,
-				)
-				expect(printed.exitCode).toBe(0)
-				expect(printed.stderr).toBe("")
-				const contract = JSON.parse(printed.stdout)
-				expect(contract.cwd).toBe(launch.cwd)
-				expect(contract.argv).toEqual(["opencode"])
-				expect(contract.environment.OPENCODE_CONFIG).toBeUndefined()
-				expect(contract.environment.AGENCY_WRITABLE_CHECKOUT).toBe(
-					launch.checkoutPath,
-				)
-				expect(contract.environment.OPENCODE_CONFIG_CONTENT).toBeUndefined()
-				if (launch === launches[1]) {
-					const context = parseJson(
-						await runCli(["context", ".", "--json"], contract.cwd),
-					)
-					expect(context.target).toMatchObject({
-						kind: "phase",
-						taskId: "pipeline",
-						phaseId: "build",
-					})
-				}
-				const environment = {
-					...process.env,
-					...contract.environment,
-					XDG_CONFIG_HOME: isolatedConfigHome,
-					OPENCODE_DISABLE_AUTOUPDATE: "1",
-					OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
-					OPENCODE_DISABLE_MODELS_FETCH: "1",
-					OPENCODE_CONFIG_CONTENT: JSON.stringify({
-						model: "opencode/big-pickle",
-					}),
-				}
-				const probe = Bun.spawnSync(["opencode", "debug", "agent", "build"], {
-					cwd: contract.cwd,
-					env: environment,
-				})
-				expect(probe.exitCode, probe.stderr.toString()).toBe(0)
-				const agent = JSON.parse(probe.stdout.toString())
-				expect(agent.permission).toEqual(
-					expect.arrayContaining([
-						expect.objectContaining({
-							permission: "external_directory",
-							pattern: join(workbaseRoot, "*"),
-							action: "allow",
-						}),
-					]),
-				)
-				const configProbe = Bun.spawnSync(["opencode", "debug", "config"], {
-					cwd: contract.cwd,
-					env: environment,
-				})
-				expect(configProbe.exitCode).toBe(0)
-				const effectiveConfig = JSON.parse(configProbe.stdout.toString())
-				expect(effectiveConfig.permission.external_directory).toMatchObject({
-					[join(workbaseRoot, "*")]: "allow",
-				})
-				expect(effectiveConfig.plugin_origins).toEqual(
-					expect.arrayContaining([
-						expect.objectContaining({
-							spec: expect.stringContaining("agency-repository-skills.ts"),
-						}),
-					]),
-				)
-				if (launch.skillPath) {
-					expect(effectiveConfig.skills.paths).toContain(
-						`${launch.skillPath}${sep}.`,
-					)
-					const skillProbe = Bun.spawnSync(
-						[
-							"opencode",
-							"debug",
-							"agent",
-							"build",
-							"--tool",
-							"skill",
-							"--params",
-							JSON.stringify({ name: "repository-skill" }),
-						],
-						{ cwd: contract.cwd, env: environment },
-					)
-					expect(skillProbe.exitCode).toBe(0)
-					expect(
-						JSON.parse(skillProbe.stdout.toString()).result.output,
-					).toContain("Repository skill content.")
-				} else {
-					expect(
-						(effectiveConfig.skills?.paths ?? []).filter((path: string) =>
-							path.endsWith(`${sep}.`),
-						),
-					).toEqual([])
-				}
-				if (launch === launches[0]) {
-					expect(effectiveConfig.instructions).toContain(".agency/AGENTS.md")
-					expect(effectiveConfig.agent.agency).toBeUndefined()
-					expect(effectiveConfig.references).toEqual({
-						workbase: {
-							path: "..",
-							description:
-								"Complete Agency workbase context; write authority still comes only from agency context",
-						},
-					})
-					for (const document of documents) {
-						const read = Bun.spawnSync(
-							[
-								"opencode",
-								"debug",
-								"agent",
-								"build",
-								"--tool",
-								"read",
-								"--params",
-								JSON.stringify({ filePath: document }),
-							],
-							{ cwd: contract.cwd, env: environment },
-						)
-						expect(read.exitCode).toBe(0)
-						const result = JSON.parse(read.stdout.toString())
-						expect(result.result.output).toContain(`<path>${document}</path>`)
-					}
-				}
-			}
-
-			const agencyBin = join(parent, "bin")
-			await mkdir(agencyBin)
-			await symlink(cliPath, join(agencyBin, "agency"))
-			const directEnvironment: Record<string, string | undefined> = {
-				...process.env,
-				PATH: `${agencyBin}:${process.env.PATH ?? ""}`,
-				XDG_CONFIG_HOME: isolatedConfigHome,
-				OPENCODE_DISABLE_AUTOUPDATE: "1",
-				OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
-				OPENCODE_DISABLE_MODELS_FETCH: "1",
-			}
-			delete directEnvironment.OPENCODE_CONFIG
-			delete directEnvironment.OPENCODE_CONFIG_CONTENT
-			delete directEnvironment.AGENCY_WORKBASE
-			delete directEnvironment.AGENCY_TASK_ID
-			delete directEnvironment.AGENCY_PHASE_ID
-			delete directEnvironment.AGENCY_WRITABLE_CHECKOUT
-			const directDirectories = [
-				join(workbaseRoot, "tasks/example"),
-				join(workbaseRoot, "tasks/pipeline"),
-				join(workbaseRoot, "tasks/pipeline/phases/build"),
-				join(workbaseRoot, "epics/delivery"),
-			]
-			for (const cwd of directDirectories) {
-				const probe = Bun.spawnSync(["opencode", "debug", "agent", "build"], {
-					cwd,
-					env: directEnvironment,
-				})
-				expect(probe.exitCode).toBe(0)
-				const agent = JSON.parse(probe.stdout.toString())
-				expect(agent.permission).toEqual(
-					expect.arrayContaining([
-						expect.objectContaining({
-							permission: "external_directory",
-							pattern: join(workbaseRoot, "*"),
-							action: "allow",
-						}),
-					]),
-				)
-				const configProbe = Bun.spawnSync(["opencode", "debug", "config"], {
-					cwd,
-					env: directEnvironment,
-				})
-				expect(configProbe.exitCode).toBe(0)
-				const effectiveConfig = JSON.parse(configProbe.stdout.toString())
-				expect(effectiveConfig.permission.external_directory).toMatchObject({
-					[join(workbaseRoot, "*")]: "allow",
-				})
-				expect(effectiveConfig.plugin_origins).toEqual(
-					expect.arrayContaining([
-						expect.objectContaining({
-							spec: expect.stringContaining("agency-repository-skills.ts"),
-						}),
-					]),
-				)
-				for (const document of documents) {
-					const read = Bun.spawnSync(
-						[
-							"opencode",
-							"debug",
-							"agent",
-							"build",
-							"--tool",
-							"read",
-							"--params",
-							JSON.stringify({ filePath: document }),
-						],
-						{ cwd, env: directEnvironment },
-					)
-					expect(read.exitCode).toBe(0)
-					expect(JSON.parse(read.stdout.toString()).result.output).toContain(
-						`<path>${document}</path>`,
-					)
-				}
-			}
-			const denied = Bun.spawnSync(["opencode", "debug", "agent", "build"], {
-				cwd: directDirectories[0],
-				env: {
-					...directEnvironment,
-					OPENCODE_CONFIG_CONTENT: JSON.stringify({
-						model: "opencode/big-pickle",
-						permission: { external_directory: { "*": "deny" } },
-					}),
-				},
-			})
-			expect(denied.exitCode).toBe(0)
-			const deniedRules = JSON.parse(denied.stdout.toString()).permission
-			const managedRule = deniedRules.findIndex(
-				(rule: any) =>
-					rule.permission === "external_directory" &&
-					rule.pattern === join(workbaseRoot, "*") &&
-					rule.action === "allow",
-			)
-			const userRule = deniedRules.findLastIndex(
-				(rule: any) =>
-					rule.permission === "external_directory" &&
-					rule.pattern === "*" &&
-					rule.action === "deny",
-			)
-			expect(managedRule).toBeGreaterThanOrEqual(0)
-			expect(userRule).toBeGreaterThan(managedRule)
-			for (const cwd of [
-				join(workbaseRoot, "tasks/example"),
-				join(workbaseRoot, "tasks/pipeline/phases/build"),
-			]) {
-				const manualSkill = Bun.spawnSync(
-					[
-						"opencode",
-						"debug",
-						"agent",
-						"build",
-						"--tool",
-						"skill",
-						"--params",
-						JSON.stringify({ name: "repository-skill" }),
-					],
-					{ cwd, env: directEnvironment },
-				)
-				expect(manualSkill.exitCode, manualSkill.stderr.toString()).toBe(0)
-				expect(
-					JSON.parse(manualSkill.stdout.toString()).result.output,
-				).toContain("Repository skill content.")
-			}
-
-			parseJson(
-				await runCli(["task", "status", "example", "dropped", "--json"], root),
-			)
-			const blocked = await runCli(
-				["work", "--task", "example", "--agent", "noop"],
-				root,
-			)
-			expect(blocked.exitCode).toBe(1)
-			expect(blocked.stderr).toContain("Task status is dropped")
-			expect(
-				parseJson(await runCli(["task", "show", "example", "--json"], root))
-					.data.status,
-			).toBe("dropped")
-
-			const resumedTask = await runCli(
-				["work", "--task", "example", "--agent", "noop", "--force"],
-				root,
-			)
-			expect(resumedTask).toMatchObject({ exitCode: 0, stderr: "" })
-			expect(resumedTask.stdout).toContain(
-				"Reopened task/example from dropped 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",
-					"--agent",
-					"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")
-		},
-		360_000,
-	)
-
-	test("envelopes help and version output in machine mode", async () => {
-		const help = await runCli(["status", "--help", "--json"])
-		expect(parseJson(help)).toContain("Usage: agency status")
-
-		const version = await runCli(["status", "--version", "--json"])
-		expect(parseJson(version)).toEqual({ version: "0.0.0-development" })
-
-		const jsonlHelp = await runCli(["graph", "--help", "--jsonl"])
-		expect(parseJson(jsonlHelp)).toContain("Usage: agency graph")
-
-		const invalidJsonl = await runCli([
-			"graph",
-			"--jsonl",
-			"--include",
-			"secrets",
-		])
-		expect(invalidJsonl.exitCode).toBe(1)
-		expect(invalidJsonl.stderr).toBe("")
-		expect(invalidJsonl.stdout.trim().split("\n")).toHaveLength(1)
-		expect(JSON.parse(invalidJsonl.stdout)).toMatchObject({
-			version: 1,
-			ok: false,
-			error: { code: "CLI_USAGE" },
-		})
-	})
-
-	test("runs a multi-phase domain workflow through subprocesses", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const root = join(parent, "workbase")
-		const source = join(parent, "source")
-
-		const git = Bun.spawn(["git", "init", "--initial-branch=main", source], {
-			stdout: "ignore",
-			stderr: "pipe",
-		})
-		expect(await git.exited).toBe(0)
-		await runGit([
-			"-C",
-			source,
-			"remote",
-			"add",
-			"origin",
-			"https://example.com/agency-tests/source.git",
-		])
-
-		expect(parseJson(await runCli(["init", root, "--json"]))).toEqual({
-			root,
-		})
-		const workbaseRoot = await realpath(root)
-		expect(
-			parseJson(
-				await runCli(["repo", "link", "agency", source, "--json"], root),
-			),
-		).toEqual({
-			alias: "agency",
-			path: join(workbaseRoot, "repos/agency"),
-		})
-		for (const alias of ["effect", "tooling"]) {
-			parseJson(await runCli(["repo", "link", alias, source, "--json"], root))
-		}
-
-		const epic = parseJson(
-			await runCli(
-				[
-					"epic",
-					"create",
-					"delivery",
-					"--ticket-url",
-					"https://example.com/epics/delivery",
-					"--repo",
-					"agency:main",
-					"--json",
-				],
-				root,
-			),
-		)
-		expect(epic).toMatchObject({
-			id: "delivery",
-			data: { repos: [{ repo: "agency", ref: "main" }], tasks: [] },
-		})
-
-		const task = parseJson(
-			await runCli(
-				[
-					"task",
-					"create",
-					"ship",
-					"--ticket-url",
-					"https://example.com/tasks/ship",
-					"--epic",
-					"delivery",
-					"--multi-phase",
-					"--json",
-				],
-				root,
-			),
-		)
-		expect(task).toMatchObject({
-			id: "ship",
-			data: { epic: "delivery", phases: [] },
-		})
-
-		for (const [id, branch] of [
-			["prepare", "task/ship-prepare"],
-			["implement", "task/ship-implement"],
-		] as const) {
-			const phase = parseJson(
-				await runCli(
-					[
-						"phase",
-						"create",
-						"ship",
-						id,
-						"--repo",
-						"agency",
-						"--branch",
-						branch,
-						"--base",
-						"main",
-						"--json",
-					],
-					root,
-				),
-			)
-			expect(phase).toMatchObject({ taskId: "ship", id })
-		}
-
-		const release = parseJson(
-			await runCli(
-				[
-					"phase",
-					"create",
-					"ship",
-					"release",
-					"--repo",
-					"agency",
-					"--branch",
-					"task/ship-release",
-					"--base",
-					"main",
-					"--depends-on",
-					"prepare",
-					"--depends-on",
-					"implement",
-					"--reference",
-					"effect:main",
-					"--reference",
-					"tooling:main",
-					"--json",
-				],
-				root,
-			),
-		)
-		expect(release.data).toMatchObject({
-			branch: "task/ship-release",
-			base: "main",
-			repos: [
-				{ repo: "effect", ref: "main" },
-				{ repo: "tooling", ref: "main" },
-			],
-		})
-
-		const epicList = parseJson(await runCli(["epic", "list", "--json"], root))
-		expect(epicList).toHaveLength(1)
-		expect(epicList[0].data.tasks).toEqual([{ id: "ship" }])
-
-		const taskShow = parseJson(
-			await runCli(["task", "show", "ship", "--json"], root),
-		)
-		expect(taskShow.data.phases).toEqual([
-			{ id: "prepare" },
-			{ id: "implement" },
-			{ id: "release", dependsOn: ["prepare", "implement"] },
-		])
-		const plainTaskShow = await runCli(["task", "show", "ship"], root)
-		expect(plainTaskShow.exitCode).toBe(0)
-		expect(plainTaskShow.stdout).toContain(
-			"ticketUrl: https://example.com/tasks/ship",
-		)
-		expect(plainTaskShow.stderr).toBe("")
-
-		const phaseList = parseJson(
-			await runCli(["phase", "list", "ship", "--json"], root),
-		)
-		expect(phaseList.map((phase: { id: string }) => phase.id)).toEqual([
-			"prepare",
-			"implement",
-			"release",
-		])
-		const phaseTable = await runCli(
-			["phase", "list", "ship", "--repository", "agency", "--no-pr"],
-			root,
-		)
-		expect(phaseTable.stdout).toMatch(
-			/PHASE\s+PARENT\s+STATUS\s+READINESS\s+REPOSITORIES\s+BRANCH/,
-		)
-		expect(phaseTable.stdout.indexOf("prepare")).toBeLessThan(
-			phaseTable.stdout.indexOf("implement"),
-		)
-
-		const phaseShow = parseJson(
-			await runCli(["phase", "show", "ship", "release", "--json"], root),
-		)
-		expect(phaseShow).toMatchObject({ taskId: "ship", id: "release" })
-
-		const status = parseJson(await runCli(["status", "--json"], root))
-		expect(status).toMatchObject({
-			root: workbaseRoot,
-			epicCount: 1,
-			taskCount: 1,
-			phaseCount: 3,
-			valid: true,
-			issues: [],
-		})
-		const doctor = parseJson(await runCli(["doctor", "--json"], root))
-		expect(doctor).toMatchObject({
-			version: 1,
-			root: workbaseRoot,
-			checks: expect.arrayContaining([
-				expect.objectContaining({ id: "tool.git", status: "pass" }),
-				expect.objectContaining({ id: "workbase.validation", status: "pass" }),
-			]),
-		})
-
-		const validation = parseJson(
-			await runCli(["validate", root, "--json"], parent),
-		)
-		expect(validation).toEqual({
-			root,
-			issues: [],
-			epicCount: 1,
-			taskCount: 1,
-			phaseCount: 3,
-			valid: true,
-		})
-	}, 30_000)
-
-	test("restores portable repositories in a fresh workbase clone", async () => {
-		const parent = await createTempDir()
-		tempDirs.push(parent)
-		const sourceWorktree = join(parent, "source-worktree")
-		const source = join(parent, "source.git")
-		const root = join(parent, "workbase")
-		const restored = join(parent, "restored")
-
-		await runGit(["init", "--initial-branch=main", sourceWorktree])
-		await Bun.write(join(sourceWorktree, "README.md"), "portable\n")
-		await runGit([
-			"-C",
-			sourceWorktree,
-			"config",
-			"user.email",
-			"test@example.com",
-		])
-		await runGit(["-C", sourceWorktree, "config", "user.name", "Test"])
-		await runGit(["-C", sourceWorktree, "add", "README.md"])
-		await runGit([
-			"-C",
-			sourceWorktree,
-			"-c",
-			"commit.gpgsign=false",
-			"commit",
-			"-m",
-			"initial",
-		])
-		await runGit(["clone", "--bare", sourceWorktree, source])
-		const daemon = await startGitDaemon(parent)
-
-		try {
-			parseJson(await runCli(["init", root, "--json"], parent))
-			parseJson(
-				await runCli(["repo", "add", "agency", daemon.remote, "--json"], root),
-			)
-			parseJson(
-				await runCli(
-					[
-						"task",
-						"create",
-						"portable",
-						"--repo",
-						"agency",
-						"--branch",
-						"feat/portable",
-						"--base",
-						"main",
-						"--json",
-					],
-					root,
-				),
-			)
-
-			await runGit(["init", "--initial-branch=main", root])
-			await runGit(["-C", root, "config", "user.email", "test@example.com"])
-			await runGit(["-C", root, "config", "user.name", "Test"])
-			await runGit(["-C", root, "add", "."])
-			await runGit([
-				"-C",
-				root,
-				"-c",
-				"commit.gpgsign=false",
-				"commit",
-				"-m",
-				"portable workbase",
-			])
-			const tracked = await runGit(["-C", root, "ls-files"])
-			expect(tracked).toContain("agency.json")
-			expect(tracked).not.toContain("repos/agency")
-
-			await runGit(["clone", root, restored])
-			const planned = parseJson(
-				await runCli(["repo", "setup", "--dry-run", "--json"], restored),
-			)
-			expect(planned.actions).toEqual([
-				expect.objectContaining({
-					alias: "agency",
-					kind: "materialize",
-					status: "planned",
-				}),
-			])
-			expect(await Bun.file(join(restored, "repos/agency/HEAD")).exists()).toBe(
-				false,
-			)
-
-			const applied = parseJson(
-				await runCli(["repo", "setup", "--apply", "--json"], restored),
-			)
-			expect(applied.actions[0]).toMatchObject({
-				alias: "agency",
-				status: "applied",
-			})
-			expect((await stat(join(restored, "repos/agency/HEAD"))).isFile()).toBe(
-				true,
-			)
-
-			const prepared = parseJson(
-				await runCli(["work", "prepare", "portable", "--json"], restored),
-			)
-			expect(prepared.checkouts).toEqual([
-				expect.objectContaining({
-					repo: "agency",
-					action: "created",
-				}),
-			])
-			expect(
-				await Bun.file(
-					join(restored, "tasks/portable/code/agency/README.md"),
-				).text(),
-			).toBe("portable\n")
-		} finally {
-			daemon.process.kill()
-			await daemon.process.exited
-		}
-	}, 30_000)
-})