@markjaquith/agency 3.2.13 → 3.2.15

package/src/services/IntegrationService.test.ts

@@ -1,1091 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { createHash } from "node:crypto"
-import { mkdir, stat, symlink, unlink, utimes } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { pathToFileURL } from "node:url"
-import { cleanupTempDir, createTempDir, runTestEffect } from "../test-utils"
-import { managedWorkbaseAgents } from "../workbase/agents-file"
-import { managedWorkbaseOpencode } from "../workbase/opencode-file"
-import {
-	canUpdateManagedWorkbaseOpencodePlugin,
-	managedWorkbaseOpencodePlugin,
-} from "../workbase/opencode-plugin-file"
-import { managedWorkbaseOpencodeTui } from "../workbase/opencode-tui-file"
-import {
-	canUpdateManagedWorkbaseOpencodeTuiPlugin,
-	managedWorkbaseOpencodeTuiPlugin,
-} from "../workbase/opencode-tui-plugin-file"
-import { IntegrationService } from "./IntegrationService"
-import { FileSystemService } from "./FileSystemService"
-
-const write = async (root: string, path: string, content: string) => {
-	const fullPath = join(root, path)
-	await mkdir(dirname(fullPath), { recursive: true })
-	await Bun.write(fullPath, content)
-}
-
-const managed = (prefix: string, body: string, suffix = "") => {
-	const checksum = createHash("sha256").update(body).digest("hex")
-	return `${prefix}${checksum}${suffix}\n\n${body}`
-}
-
-const managedBody = (content: string) =>
-	content.slice(content.indexOf("\n\n") + 2)
-
-const legacyCommand = (content: string) =>
-	content.replace(
-		/^---\n/,
-		`---\n# agency-managed: sha256=${createHash("sha256").update(content).digest("hex")}\n`,
-	)
-
-const status = (root: string) =>
-	runTestEffect(
-		IntegrationService.pipe(Effect.flatMap((service) => service.status(root))),
-	)
-
-const sync = (root: string) =>
-	runTestEffect(
-		IntegrationService.pipe(Effect.flatMap((service) => service.sync(root))),
-	)
-
-describe("IntegrationService", () => {
-	let root: string
-
-	beforeEach(async () => {
-		root = await createTempDir()
-		await write(root, "agency.json", '{"version":2}\n')
-	})
-
-	afterEach(async () => cleanupTempDir(root))
-
-	test("reports missing and current managed files without writing", async () => {
-		expect((await status(root)).files.map(({ state }) => state)).toEqual([
-			"missing",
-			"missing",
-			"missing",
-			"missing",
-			"missing",
-		])
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).exists()).toBe(false)
-
-		await write(root, ".agency/AGENTS.md", managedWorkbaseAgents)
-		await write(root, ".opencode/opencode.jsonc", managedWorkbaseOpencode)
-		await write(
-			root,
-			".opencode/plugins/agency-repository-skills.ts",
-			managedWorkbaseOpencodePlugin,
-		)
-		await write(root, ".opencode/tui.jsonc", managedWorkbaseOpencodeTui)
-		await write(
-			root,
-			".opencode/tui/agency-debug.ts",
-			managedWorkbaseOpencodeTuiPlugin,
-		)
-		expect((await status(root)).files.map(({ state }) => state)).toEqual([
-			"managed",
-			"managed",
-			"managed",
-			"managed",
-			"managed",
-		])
-	})
-
-	test("inspects each integration path once per status call", async () => {
-		const service = await Effect.runPromise(
-			Effect.provide(FileSystemService, FileSystemService.Default),
-		)
-		const inspected = new Map<string, number>()
-		const instrumented = {
-			...service,
-			inspectFile: (path: string) => {
-				inspected.set(path, (inspected.get(path) ?? 0) + 1)
-				return service.inspectFile(path)
-			},
-		}
-
-		await runTestEffect(
-			IntegrationService.pipe(
-				Effect.flatMap((integration) => integration.statusRoot(root)),
-				Effect.provideService(FileSystemService, instrumented),
-			),
-		)
-
-		expect(inspected.size).toBe(8)
-		expect([...inspected.values()]).toEqual(Array(8).fill(1))
-	})
-
-	test("inspects integration and legacy paths once per synchronized call", async () => {
-		const service = await Effect.runPromise(
-			Effect.provide(FileSystemService, FileSystemService.Default),
-		)
-		const inspected = new Map<string, number>()
-		const instrumented = {
-			...service,
-			inspectFile: (path: string) => {
-				inspected.set(path, (inspected.get(path) ?? 0) + 1)
-				return service.inspectFile(path)
-			},
-		}
-
-		await runTestEffect(
-			IntegrationService.pipe(
-				Effect.flatMap((integration) => integration.syncRoot(root)),
-				Effect.provideService(FileSystemService, instrumented),
-			),
-		)
-
-		expect(inspected.size).toBe(11)
-		expect([...inspected.values()]).toEqual(Array(11).fill(1))
-	})
-
-	test("reports customized and checksum-safe drifted files", async () => {
-		await write(root, ".agency/AGENTS.md", "# Custom instructions\n")
-		await write(
-			root,
-			".opencode/opencode.jsonc",
-			managed("// agency-managed: sha256=", '{"references":{}}\n'),
-		)
-
-		expect((await status(root)).files.map(({ state }) => state)).toEqual([
-			"customized",
-			"drifted",
-			"missing",
-			"missing",
-			"missing",
-		])
-	})
-
-	test("generates the complete Agency command fast paths with precedence", () => {
-		const body = managedBody(managedWorkbaseAgents)
-
-		expect(body.indexOf("## Command Fast Paths")).toBeLessThan(
-			body.indexOf("## Bootstrap"),
-		)
-		expect(managedWorkbaseAgents).toContain(
-			"take precedence over separately installed Agency skill guidance",
-		)
-		for (const recipe of [
-			"Create a single-phase task only",
-			"agency work prepare <slug> --evidence",
-			"Materialize an existing execution unit without starting it",
-			"agency sync <task> [phase] --json",
-			"agency phase create <task> <new-phase> --first-phase <existing-phase>",
-			"agency archive task <task> --dry-run --json",
-			"agency task create <slug> --review <alias>",
-			"agency status --json",
-			"agency task status <task> dropped --if-revision <revision> --json",
-			"Continue already materialized work",
-			"agency pr create <task> [phase]",
-			"agency task status <task> done --if-revision <revision> --no-pull-request",
-			"agency task create <slug> --multi-phase",
-			"agency task handoff <investigation-task> <new-task>",
-			"agency review refresh <task> --if-revision <revision> --json",
-		]) {
-			expect(managedWorkbaseAgents).toContain(recipe)
-		}
-		expect(managedWorkbaseAgents).toContain("agency push --json")
-		expect(managedWorkbaseAgents).toContain("agency-execution-v1")
-		expect(managedWorkbaseAgents).toContain("agency context . --json")
-		expect(managedWorkbaseAgents).toContain(
-			"Pass `--full` only when document prose or low-level VCS details are needed",
-		)
-		expect(managedWorkbaseAgents).not.toContain(
-			"agency context . --full --json",
-		)
-		expect(managedWorkbaseAgents).toContain(
-			"Never pass `--work` or `--auto` to `agency task create`",
-		)
-		expect(managedWorkbaseAgents).toContain(
-			"Use `agency <command> --help` only as a recovery",
-		)
-		expect(managedWorkbaseAgents).not.toContain("`agency --help`")
-		expect(managedWorkbaseAgents).not.toContain(
-			"`agency worktree prepare <task>",
-		)
-	})
-
-	test("generates a dynamic workbase plugin", () => {
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"process.env.AGENCY_WRITABLE_CHECKOUT",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'import type { Plugin, PluginModule } from "@opencode-ai/plugin/v1"',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"export const AgencyPlugin = plugin",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain('id: "agency"')
-		expect(managedWorkbaseOpencodePlugin).toContain("setup,")
-		expect(managedWorkbaseOpencodePlugin).toContain("server: plugin")
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'["agency", "context", ".", "--compact", "--json"]',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'join(checkout, ".claude", "skills")',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'join(checkout, ".agents", "skills")',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'join(checkout, ".opencode", "skills")',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'config.permission.external_directory = { [join(root, "*")]: "allow" }',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"config.skills.paths = [...new Set",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain('"chat.message"')
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"if (!Array.isArray(parts)) return",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'"experimental.chat.system.transform"',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain('"shell.env"')
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"if (context?.target !== launchTarget) return",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"agencyContext(directory, false)",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"result.validation?.valid !== true",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"dirname(document) !== resolve(directory)",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"!result.authority?.writable?.checkoutPath",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain('status !== "working"')
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			'output.env.AGENCY_INVOCATION_SOURCE = "agent"',
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"output.env.AGENCY_SESSION_ID = sessionID",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"Do not invoke agency work for this target",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"as the default implementation directory",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"Set each tool's working directory to that checkout when supported",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"Run Agency lifecycle and context commands from the task or phase directory",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			"reference checkouts reported by Agency context are read-only",
-		)
-		expect(managedWorkbaseOpencodePlugin).toContain(
-			".map((path) => `${path}${sep}.`)",
-		)
-		expect(
-			canUpdateManagedWorkbaseOpencodePlugin(managedWorkbaseOpencodePlugin),
-		).toBe(true)
-		expect(
-			canUpdateManagedWorkbaseOpencodePlugin(
-				managedWorkbaseOpencodePlugin.replace("config.skills ??= {}", ""),
-			),
-		).toBe(false)
-	})
-
-	const testWorkerIdentity = async ({
-		target,
-		launchTarget,
-		phase,
-	}: {
-		readonly target:
-			| { readonly kind: "task"; readonly taskId: string }
-			| {
-					readonly kind: "phase"
-					readonly taskId: string
-					readonly phaseId: string
-			  }
-		readonly launchTarget: string
-		readonly phase?: string
-	}) => {
-		const path = join(root, "agency-repository-skills.ts")
-		const checkoutPath = join(root, "code/agency")
-		const contextResponse = JSON.stringify({
-			version: 1,
-			ok: true,
-			result: {
-				workbase: { root },
-				target: {
-					...target,
-					path: join(root, phase ? "PHASE.md" : "TASK.md"),
-				},
-				authority: {
-					mode: "execution",
-					writable: { checkoutPath },
-				},
-				documents: phase
-					? { phase: { data: { status: "working" } } }
-					: { task: { data: { status: "working" } } },
-				validation: { valid: true, warnings: [] },
-			},
-		})
-		await Bun.write(
-			path,
-			managedWorkbaseOpencodePlugin
-				.replace("const contextTarget =", "export const contextTarget =")
-				.replace("const agencyContext =", "export const agencyContext =")
-				.replace(
-					"const workerLaunchTarget =",
-					"export const workerLaunchTarget =",
-				),
-		)
-		const originalSpawn = Bun.spawn
-		Bun.spawn = (() =>
-			({
-				stdout: new Response(contextResponse).body!,
-				exited: Promise.resolve(0),
-			}) as ReturnType<typeof Bun.spawn>) as typeof Bun.spawn
-		try {
-			const generated = await import(
-				`${pathToFileURL(path).href}?worker-identity=${encodeURIComponent(launchTarget)}`
-			)
-			expect(
-				generated.workerLaunchTarget([
-					{
-						type: "text",
-						text: `Agency worker launch target: ${launchTarget}. Start the task.`,
-					},
-				]),
-			).toBe(launchTarget)
-			expect(generated.workerLaunchTarget(undefined)).toBeUndefined()
-			expect(
-				generated.contextTarget({
-					target,
-					authority: { mode: "execution" },
-				}),
-			).toBe(launchTarget)
-			expect(await generated.agencyContext(root)).toMatchObject({
-				root,
-				target: launchTarget,
-				task: "example",
-				phase,
-			})
-			expect(generated.default).toMatchObject({
-				id: "agency",
-				setup: expect.any(Function),
-				server: generated.AgencyPlugin,
-			})
-			const hooks = await generated.AgencyPlugin({ directory: root } as never)
-			await hooks["chat.message"]!(
-				{ sessionID: "worker-session" } as never,
-				{
-					parts: [
-						{
-							type: "text",
-							text: `Agency worker launch target: ${launchTarget}. Start the task.`,
-						},
-					],
-				} as never,
-			)
-			await hooks["chat.message"]!(
-				{ sessionID: "mismatched-session" } as never,
-				{
-					parts: [
-						{
-							type: "text",
-							text: "Agency worker launch target: execution-unit:task/other. Start the task.",
-						},
-					],
-				} as never,
-			)
-
-			const system = { system: [] as string[] }
-			await hooks["experimental.chat.system.transform"]!(
-				{ sessionID: "worker-session" } as never,
-				system,
-			)
-			expect(system.system).toHaveLength(1)
-			expect(system.system[0]).toContain(`active worker for ${launchTarget}`)
-			expect(system.system[0]).toContain(
-				`${checkoutPath} as the default implementation directory`,
-			)
-			expect(system.system[0]).toContain(
-				"Run Agency lifecycle and context commands from the task or phase directory",
-			)
-			expect(system.system[0]).toContain(
-				"reference checkouts reported by Agency context are read-only",
-			)
-			const mismatchedSystem = { system: [] as string[] }
-			await hooks["experimental.chat.system.transform"]!(
-				{ sessionID: "mismatched-session" } as never,
-				mismatchedSystem,
-			)
-			expect(mismatchedSystem.system).toEqual([])
-
-			const shell = { env: {} as Record<string, string> }
-			await hooks["shell.env"]!({ sessionID: "worker-session" } as never, shell)
-			expect(shell.env).toMatchObject({
-				AGENCY_SESSION_ID: "worker-session",
-				AGENCY_TARGET: launchTarget,
-				AGENCY_WORKBASE: root,
-				AGENCY_TASK_ID: "example",
-				AGENCY_WRITABLE_CHECKOUT: checkoutPath,
-			})
-			if (phase) expect(shell.env.AGENCY_PHASE_ID).toBe(phase)
-		} finally {
-			Bun.spawn = originalSpawn
-		}
-	}
-
-	test("binds validated task worker identity to an OpenCode session", () =>
-		testWorkerIdentity({
-			target: { kind: "task", taskId: "example" },
-			launchTarget: "execution-unit:task/example",
-		}))
-
-	test("binds validated phase worker identity to an OpenCode session", () =>
-		testWorkerIdentity({
-			target: { kind: "phase", taskId: "example", phaseId: "build" },
-			launchTarget: "execution-unit:phase/example/build",
-			phase: "build",
-		}))
-
-	test("registers the workbase reference through the OpenCode V2 API", async () => {
-		const path = join(root, ".opencode/plugins/agency-repository-skills.ts")
-		await write(
-			root,
-			".opencode/plugins/agency-repository-skills.ts",
-			managedWorkbaseOpencodePlugin,
-		)
-		const generated = await import(`${pathToFileURL(path).href}?v2-setup`)
-		let reference:
-			| {
-					name: string
-					source: { type: string; path: string; description: string }
-			  }
-			| undefined
-
-		await generated.default.setup({
-			reference: {
-				transform: async (callback: (references: unknown) => void) =>
-					callback({
-						list: () => [],
-						add: (
-							name: string,
-							source: {
-								type: string
-								path: string
-								description: string
-							},
-						) => {
-							reference = { name, source }
-						},
-					}),
-			},
-			skill: { transform: async () => {} },
-		})
-
-		expect(reference).toEqual({
-			name: "workbase",
-			source: {
-				type: "local",
-				path: root,
-				description:
-					"Complete Agency workbase context; write authority still comes only from agency context",
-			},
-		})
-	})
-
-	test("registers a TUI-only /agency-debug diagnostic", async () => {
-		const config = JSON.parse(managedBody(managedWorkbaseOpencodeTui))
-		expect(config).toEqual({
-			$schema: "https://opencode.ai/tui.json",
-			plugin: ["./tui/agency-debug.ts"],
-		})
-
-		const path = join(root, ".opencode/tui/agency-debug.ts")
-		await write(
-			root,
-			".opencode/tui/agency-debug.ts",
-			managedWorkbaseOpencodeTuiPlugin,
-		)
-		const module = await import(pathToFileURL(path).href)
-		let clientReads = 0
-
-		const runDiagnostic = async (
-			paths: string[],
-			options: {
-				ready?: boolean
-				managedReference?: boolean
-				externalDirectory?: Record<string, string>
-			} = {},
-		) => {
-			let command:
-				| {
-						slashName?: string
-						namespace?: string
-						run: () => void
-				  }
-				| undefined
-			let toast: { variant: string; message: string } | undefined
-			await module.default.tui({
-				get client() {
-					clientReads += 1
-					throw new Error("diagnostic must not access the server client")
-				},
-				state: {
-					ready: options.ready ?? true,
-					config: {
-						skills: { paths },
-						references: options.managedReference
-							? {
-									workbase: {
-										path: "..",
-										description:
-											"Complete Agency workbase context; write authority still comes only from agency context",
-									},
-								}
-							: undefined,
-						permission: options.externalDirectory
-							? { external_directory: options.externalDirectory }
-							: undefined,
-					},
-					path: { directory: join(root, "tasks", "example") },
-				},
-				keymap: {
-					registerLayer: (layer: { commands: (typeof command)[] }) => {
-						command = layer.commands[0]
-					},
-				},
-				ui: {
-					toast: (input: { variant: string; message: string }) => {
-						toast = input
-					},
-				},
-			} as never)
-			expect(command).toMatchObject({
-				namespace: "palette",
-				slashName: "agency-debug",
-			})
-			command?.run()
-			return toast
-		}
-
-		expect(await runDiagnostic(["/checkout/.agents/skills/."])).toMatchObject({
-			variant: "success",
-			message: expect.stringContaining("Server plugin: initialized"),
-		})
-		expect(
-			await runDiagnostic([], {
-				managedReference: true,
-				externalDirectory: { [join(root, "*")]: "allow" },
-			}),
-		).toMatchObject({
-			variant: "success",
-			message: expect.stringContaining("workbase access registered"),
-		})
-		expect(
-			await runDiagnostic([], {
-				externalDirectory: { [join(root, "*")]: "allow" },
-			}),
-		).toMatchObject({
-			variant: "warning",
-			message: expect.stringContaining("Server plugin: indeterminate"),
-		})
-		expect(await runDiagnostic([])).toMatchObject({
-			variant: "warning",
-			message: expect.stringContaining("Server plugin: indeterminate"),
-		})
-		expect(clientReads).toBe(0)
-		expect(managedWorkbaseOpencodeTuiPlugin).not.toContain("chat.message")
-		expect(
-			canUpdateManagedWorkbaseOpencodeTuiPlugin(
-				managedWorkbaseOpencodeTuiPlugin,
-			),
-		).toBe(true)
-	})
-
-	test("generates context-first safety and execution closeout guidance", () => {
-		const body = managedBody(managedWorkbaseAgents)
-
-		expect(body).toContain("agency context . --json")
-		expect(body).toContain("agency next --json")
-		expect(body).toContain("agency <command> --help")
-		expect(body).toContain("authority.writable.checkoutPath")
-		expect(body).toContain("authority.documents.writable")
-		expect(body).toContain("Only `done` satisfies a dependency")
-		expect(body).toContain("Require explicit user intent")
-		expect(body).toContain(
-			"explicit request for a new, separate, or follow-up item",
-		)
-		expect(body).toContain("agency task handoff")
-		expect(body).toContain(
-			"Creation and handoff do not imply worktree preparation",
-		)
-		expect(body).toContain("changing repository")
-		expect(body).toMatch(
-			/archiving, restoring,\s+dropping, reopening, or completing work without a pull request/,
-		)
-		expect(body).toContain("Never invent entity IDs")
-		expect(body).toContain("Preserve parent backlinks")
-		expect(body).toContain("dirty-worktree, revision")
-		expect(body).toContain("`agency work` is the human launch flow")
-		expect(body).toContain("Agency worker launch target: <target>.")
-		expect(body).toContain("environment variables and a generated")
-		expect(body).toContain("the initial instruction is a generated")
-		expect(body).toContain(
-			"External session state is never part of worker identity",
-		)
-		expect(body).toMatch(/If\s+the prompt\s+and context disagree/)
-		expect(body).toContain("marks execution work")
-		expect(body).toContain("marks execution work")
-		expect(body).toContain("formatting, type checks, build, dead-code checks")
-		expect(body).toContain("Review and commit the diff")
-		expect(body).toContain("Use `agency push`")
-		expect(body).toContain("never authors semantic commit descriptions")
-		expect(body).toContain("Run `agency validate`")
-		expect(body).toContain("only with explicit user intent")
-		expect(body).toContain("An execution unit remains `working`")
-		expect(body).toContain("It becomes `done`")
-		expect(body).toContain("Do not mark committed")
-		expect(body).toContain("creating or updating a PR")
-		expect(body).toContain("marking it ready")
-		expect(body).toMatch(/completing\s+a refinement loop/)
-		expect(body).toContain("pausing or handing off")
-		expect(body).toContain("update status")
-		expect(body).toContain("`agency sync`")
-		expect(body).toContain("`--no-pull-request --summary <text>`")
-		expect(body).toContain("`TASK.md` or `PHASE.md`")
-		expect(body).toContain("PR state, current head, diff summary")
-		expect(body).toContain("Run `agency validate` before reporting completion")
-		expect(body).toContain("agency integration status")
-		expect(body).not.toContain("SKILL.md")
-		expect(body).not.toContain("~/.agents")
-		expect(body).not.toContain(".opencode/command/agency.md")
-	})
-
-	test("generates repository add and setup guidance", () => {
-		const body = managedBody(managedWorkbaseAgents)
-
-		expect(body).toContain("## Adding a Repository")
-		expect(body).toContain("agency repo add <alias> <remote> --json")
-		expect(body).toContain(
-			"`agency repo add` mutates immediately and does not accept `--apply`",
-		)
-		expect(body).toContain("agency repo setup --dry-run")
-		expect(body).toContain("agency repo setup --apply")
-		expect(body).toMatch(
-			/repositories that are already declared\s+but locally missing/,
-		)
-		expect(body).toContain("Do not edit\n`agency.json` or `repos/` manually")
-		expect(body).toMatch(
-			/agency repo verify <alias> --json\s+agency validate --json/,
-		)
-		expect(body).toMatch(
-			/run only these checks, in order, unless\s+`agency context` reports a relevant problem/,
-		)
-	})
-
-	test("configures Agency planning with complete workbase access", () => {
-		const config = JSON.parse(managedBody(managedWorkbaseOpencode))
-
-		expect(config.instructions).toEqual([".agency/AGENTS.md"])
-		expect(config.agent).toEqual({
-			plan: {
-				disable: true,
-			},
-			"agency-plan": {
-				description:
-					"Agency planning mode. May update Agency plans and planning structure.",
-				mode: "primary",
-				prompt: expect.stringContaining("You are in Agency Plan mode"),
-				permission: {
-					question: "allow",
-					bash: {
-						"agency *": "allow",
-					},
-					edit: {
-						"*": "deny",
-						"tasks/*/TASK.md": "allow",
-						"tasks/*/phases/*/PHASE.md": "allow",
-						"epics/*/EPIC.md": "allow",
-					},
-				},
-			},
-		})
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"Explicit-new intent overrides reuse",
-		)
-		expect(config.agent.agency).toBeUndefined()
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"Start with `agency context . --json`",
-		)
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"Pass `--full` only when document prose or low-level VCS details are needed",
-		)
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"decompose it into independently deliverable tasks",
-		)
-		expect(config.agent["agency-plan"].prompt).toContain("Use `--if-revision`")
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"available ticket tools",
-		)
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"changing lifecycle state",
-		)
-		expect(config.agent["agency-plan"].prompt).toContain(
-			"Follow the managed Agency instructions and reported authority",
-		)
-		expect(config.agent["agency-plan"].permission.bash["*"]).toBeUndefined()
-		expect(config.references).toEqual({
-			workbase: {
-				path: "..",
-				description:
-					"Complete Agency workbase context; write authority still comes only from agency context",
-			},
-		})
-		expect(config.permission).toBeUndefined()
-		expect(managedBody(managedWorkbaseOpencode)).not.toContain(process.cwd())
-	})
-
-	test("treats an existing JSON OpenCode config as customized", async () => {
-		await write(root, ".opencode/opencode.json", '{"model":"test/model"}\n')
-
-		const result = await status(root)
-		expect(result.files[1]).toMatchObject({
-			name: "opencode",
-			path: join(root, ".opencode/opencode.json"),
-			state: "customized",
-			diagnostic: expect.stringContaining("cannot guarantee"),
-			remediation: expect.stringContaining("global config"),
-		})
-	})
-
-	test("treats a JSON config beside managed JSONC as customized", async () => {
-		await write(root, ".opencode/opencode.jsonc", managedWorkbaseOpencode)
-		await write(root, ".opencode/opencode.json", '{"model":"test/model"}\n')
-
-		const result = await status(root)
-		expect(result.files[1]).toMatchObject({
-			name: "opencode",
-			path: join(root, ".opencode/opencode.json"),
-			state: "customized",
-		})
-	})
-
-	test("reports actionable whole-workbase access diagnostics", async () => {
-		let result = await status(root)
-		expect(result.files[1]).toMatchObject({
-			state: "missing",
-			diagnostic: expect.stringContaining("cannot load"),
-			remediation: expect.stringContaining("integration sync"),
-		})
-
-		await write(root, ".opencode/opencode.jsonc", '{"model":"test/model"}\n')
-		result = await status(root)
-		expect(result.files[1]).toMatchObject({
-			state: "customized",
-			diagnostic: expect.stringContaining("cannot guarantee"),
-			remediation: expect.stringContaining("global config"),
-		})
-	})
-
-	test("syncs missing and drifted files while preserving customized files", async () => {
-		const customRootAgents = "# User-owned workbase instructions\n"
-		const customManagedAgents = "# Customized Agency instructions\n"
-		await write(root, "AGENTS.md", customRootAgents)
-		await write(root, ".agency/AGENTS.md", customManagedAgents)
-		await write(
-			root,
-			".opencode/opencode.jsonc",
-			managed("// agency-managed: sha256=", '{"references":{}}\n'),
-		)
-
-		const first = await sync(root)
-		expect(first.files).toMatchObject([
-			{ name: "agents", state: "customized", changed: false },
-			{ name: "opencode", state: "managed", changed: true },
-			{ name: "opencode-plugin", state: "managed", changed: true },
-			{ name: "opencode-tui", state: "managed", changed: true },
-			{ name: "opencode-tui-plugin", state: "managed", changed: true },
-		])
-		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
-			customRootAgents,
-		)
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).text()).toBe(
-			customManagedAgents,
-		)
-		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
-			managedWorkbaseOpencode,
-		)
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(false)
-		expect(
-			await Bun.file(
-				join(root, ".opencode/plugins/agency-repository-skills.ts"),
-			).text(),
-		).toBe(managedWorkbaseOpencodePlugin)
-		expect(await Bun.file(join(root, ".opencode/tui.jsonc")).text()).toBe(
-			managedWorkbaseOpencodeTui,
-		)
-		expect(
-			await Bun.file(join(root, ".opencode/tui/agency-debug.ts")).text(),
-		).toBe(managedWorkbaseOpencodeTuiPlugin)
-
-		await unlink(join(root, ".agency/AGENTS.md"))
-		const second = await sync(root)
-		expect(second.files[0]).toMatchObject({ state: "managed", changed: true })
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).text()).toBe(
-			managedWorkbaseAgents,
-		)
-		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
-			customRootAgents,
-		)
-	})
-
-	test("upgrades prior managed instructions without changing owner instructions", async () => {
-		const ownerInstructions = "# User-owned workbase instructions\n"
-		const priorInstructions = managed(
-			"<!-- agency-managed: sha256=",
-			"# Previous Agency instructions\n",
-			" -->",
-		)
-		await write(root, "AGENTS.md", ownerInstructions)
-		await write(root, ".agency/AGENTS.md", priorInstructions)
-
-		const result = await sync(root)
-
-		expect(result.files[0]).toMatchObject({
-			name: "agents",
-			state: "managed",
-			changed: true,
-		})
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).text()).toBe(
-			managedWorkbaseAgents,
-		)
-		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
-			ownerInstructions,
-		)
-	})
-
-	test("preserves user-owned checkout-skill plugins at either supported path", async () => {
-		const custom = "export default async () => ({})\n"
-		await write(root, ".opencode/plugins/agency-repository-skills.ts", custom)
-
-		let result = await sync(root)
-		expect(result.files[2]).toMatchObject({
-			name: "opencode-plugin",
-			path: join(root, ".opencode/plugins/agency-repository-skills.ts"),
-			state: "customized",
-			changed: false,
-		})
-		expect(
-			await Bun.file(
-				join(root, ".opencode/plugin/agency-repository-skills.ts"),
-			).exists(),
-		).toBe(false)
-
-		await unlink(join(root, ".opencode/plugins/agency-repository-skills.ts"))
-		await write(root, ".opencode/plugin/agency-repository-skills.ts", custom)
-		result = await sync(root)
-		expect(result.files[2]).toMatchObject({
-			path: join(root, ".opencode/plugin/agency-repository-skills.ts"),
-			state: "customized",
-			changed: false,
-		})
-	})
-
-	test("removes a checksum-valid workbase-local Pi extension", async () => {
-		const body = "export default function legacyAgencyExtension() {}\n"
-		const checksum = createHash("sha256").update(body).digest("hex")
-		const path = join(root, ".pi/extensions/agency-workbase.ts")
-		await write(
-			root,
-			".pi/extensions/agency-workbase.ts",
-			`// agency-managed: sha256=${checksum}\n\n${body}`,
-		)
-
-		await sync(root)
-		expect(await Bun.file(path).exists()).toBe(false)
-		expect(await Bun.file(join(root, ".pi")).exists()).toBe(false)
-	})
-
-	test("preserves a customized workbase-local Pi extension", async () => {
-		const custom = "export default function customPiExtension() {}\n"
-		const path = join(root, ".pi/extensions/agency-workbase.ts")
-		await write(root, ".pi/extensions/agency-workbase.ts", custom)
-
-		await sync(root)
-		expect(await Bun.file(path).text()).toBe(custom)
-	})
-
-	test("migrates a checksum-valid plugin from the legacy singular path", async () => {
-		const legacyPath = join(
-			root,
-			".opencode/plugin/agency-repository-skills.ts",
-		)
-		const pluginPath = join(
-			root,
-			".opencode/plugins/agency-repository-skills.ts",
-		)
-		await write(
-			root,
-			".opencode/plugin/agency-repository-skills.ts",
-			managedWorkbaseOpencodePlugin,
-		)
-
-		const result = await sync(root)
-
-		expect(result.files[2]).toMatchObject({
-			name: "opencode-plugin",
-			path: pluginPath,
-			state: "managed",
-			changed: true,
-		})
-		expect(await Bun.file(pluginPath).text()).toBe(
-			managedWorkbaseOpencodePlugin,
-		)
-		expect(await Bun.file(legacyPath).exists()).toBe(false)
-	})
-
-	test("preserves user-owned TUI config and diagnostic plugin", async () => {
-		const customConfig = '{"theme":"custom"}\n'
-		const customPlugin =
-			"export default { id: 'agency.debug', tui: async () => {} }\n"
-		await write(root, ".opencode/tui.json", customConfig)
-		await write(root, ".opencode/tui/agency-debug.ts", customPlugin)
-
-		const result = await sync(root)
-		expect(result.files[3]).toMatchObject({
-			name: "opencode-tui",
-			path: join(root, ".opencode/tui.json"),
-			state: "customized",
-			changed: false,
-			remediation: expect.stringContaining("plugin list"),
-		})
-		expect(result.files[4]).toMatchObject({
-			name: "opencode-tui-plugin",
-			state: "customized",
-			changed: false,
-		})
-		expect(await Bun.file(join(root, ".opencode/tui.json")).text()).toBe(
-			customConfig,
-		)
-		expect(
-			await Bun.file(join(root, ".opencode/tui/agency-debug.ts")).text(),
-		).toBe(customPlugin)
-	})
-
-	test("removes a checksum-valid legacy command and preserves a customized file", async () => {
-		const path = ".opencode/command/agency.md"
-		const legacy = legacyCommand(
-			"---\ndescription: Operate Agency work\n---\n\nLegacy command.\n",
-		)
-		await write(root, path, legacy)
-
-		await status(root)
-		expect(await Bun.file(join(root, path)).text()).toBe(legacy)
-
-		await sync(root)
-		expect(await Bun.file(join(root, path)).exists()).toBe(false)
-
-		const custom = `${legacy}User edit.\n`
-		await write(root, path, custom)
-		await sync(root)
-		expect(await Bun.file(join(root, path)).text()).toBe(custom)
-	})
-
-	test("migrates checksum-valid root instructions", async () => {
-		await write(root, "AGENTS.md", managedWorkbaseAgents)
-
-		const result = await sync(root)
-
-		expect(result.files[0]).toMatchObject({ state: "managed", changed: true })
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).text()).toBe(
-			managedWorkbaseAgents,
-		)
-		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-	})
-
-	test("preserves legacy instructions when the OpenCode config is customized", async () => {
-		await write(root, "AGENTS.md", managedWorkbaseAgents)
-		await write(root, ".opencode/opencode.json", '{"model":"test/model"}\n')
-
-		const result = await sync(root)
-
-		expect(result.files[0]).toMatchObject({ state: "managed", changed: true })
-		expect(result.files[1]).toMatchObject({
-			state: "customized",
-			changed: false,
-		})
-		expect(await Bun.file(join(root, "AGENTS.md")).text()).toBe(
-			managedWorkbaseAgents,
-		)
-	})
-
-	test("does not rewrite an already-current OpenCode configuration", async () => {
-		const path = join(root, ".opencode/opencode.jsonc")
-		await write(root, ".opencode/opencode.jsonc", managedWorkbaseOpencode)
-		const timestamp = new Date("2000-01-01T00:00:00.000Z")
-		await utimes(path, timestamp, timestamp)
-
-		const result = await sync(root)
-
-		expect(result.files[1]).toMatchObject({
-			state: "managed",
-			changed: false,
-		})
-		expect((await stat(path)).mtimeMs).toBe(timestamp.getTime())
-	})
-
-	test("does not overwrite managed files whose checksums no longer match", async () => {
-		const tampered = `${managed(
-			"<!-- agency-managed: sha256=",
-			"# Previous Agency instructions\n",
-			" -->",
-		)}User edit\n`
-		await write(root, ".agency/AGENTS.md", tampered)
-
-		const result = await sync(root)
-		expect(result.files[0]).toMatchObject({
-			state: "customized",
-			changed: false,
-		})
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).text()).toBe(
-			tampered,
-		)
-	})
-
-	test("does not overwrite a user-modified OpenCode configuration", async () => {
-		const tampered = `${managed(
-			"// agency-managed: sha256=",
-			'{"references":{}}\n',
-		)}// User edit\n`
-		await write(root, ".opencode/opencode.jsonc", tampered)
-
-		const result = await sync(root)
-		expect(result.files[1]).toMatchObject({
-			state: "customized",
-			changed: false,
-		})
-		expect(await Bun.file(join(root, ".opencode/opencode.jsonc")).text()).toBe(
-			tampered,
-		)
-	})
-
-	test("does not follow symlinked integration files", async () => {
-		const target = join(root, "custom-agents.md")
-		await Bun.write(target, "# External instructions\n")
-		await mkdir(join(root, ".agency"), { recursive: true })
-		await symlink(target, join(root, ".agency/AGENTS.md"))
-
-		const result = await sync(root)
-		expect(result.files[0]).toMatchObject({
-			state: "customized",
-			changed: false,
-		})
-		expect(await Bun.file(target).text()).toBe("# External instructions\n")
-	})
-})