@markjaquith/agency 2.47.3 → 2.48.1

package/README.md

@@ -53,7 +53,6 @@ workbase/
   .opencode/
     opencode.jsonc         # managed @agency subagent, instructions, and reference
     tui.jsonc              # managed TUI plugin registration
-    command/agency.md      # managed /agency workflow command
     plugin/agency-repository-skills.ts # managed workbase access and checkout skills
     tui/agency-debug.ts    # managed /agency-debug TUI diagnostic
   agency.json              # tracked config and portable repository declarations
@@ -84,12 +83,19 @@ workbase/
 
 Agency keeps discovery and other observational commands read-only. Run
 `agency integration status` to inspect `.agency/AGENTS.md` and
-`.opencode/opencode.jsonc`, `.opencode/tui.jsonc`, and their managed command and
-plugin files, then `agency integration sync` to create missing files or refresh
+`.opencode/opencode.jsonc`, `.opencode/tui.jsonc`, and their managed plugin
+files, then `agency integration sync` to create missing files or refresh
 checksum-safe managed files. Customized files are reported but never
-overwritten. The root
+overwritten. Sync also removes checksum-valid retired managed artifacts while
+preserving customized files at their former paths. The root
 `AGENTS.md` is user-owned and is not inspected or modified by Agency.
 
+The managed `.agency/AGENTS.md` is the complete in-workbase operating contract
+for agents. It is created by `agency init`, updated by checksum-safe integration
+sync, and requires no separately installed Agency skill. CLI help remains the
+source of truth for exact command syntax; this README provides the detailed
+product and protocol reference.
+
 When upgrading an existing workbase, synchronization moves a checksum-valid
 Agency-managed root `AGENTS.md` to `.agency/AGENTS.md` once the OpenCode config
 can load the hidden file. A customized root file, including a symlink, is
@@ -116,13 +122,6 @@ The plugin grants whole-workbase access dynamically, while the portable
 reference advertises that context to agents. Bash and Agency operations must
 still follow the write authority reported by `agency context`.
 
-OpenCode also discovers a managed `/agency` command. Use `/agency status` for a
-read-only current-work summary, `/agency start [target]` to begin or resume work
-in the active session, `/agency next` to inspect ready work, `/agency validate`
-to check the workbase, and `/agency finish [target]` for verified closeout. The
-command uses OpenCode positional arguments internally and defaults to the safe
-`status` workflow when no subcommand is supplied.
-
 Repository aliases and canonical fetch remotes are declared in tracked
 `agency.json`; local bare clones and symlinks remain ignored under
 `repos/{alias}`. A declaration contains no local path, symlink target, checkout,
@@ -882,14 +881,10 @@ payloads are exported as `@markjaquith/agency/fixtures/protocol/success.json` an
 Success, help, and version output exit `0`; usage and command failures exit `1`.
 There are no error-specific exit statuses. `graph --jsonl` streams versioned
 records on success instead of wrapping them in an envelope; JSONL failures still
-use one error envelope. See `skills/agency/references/contracts.md` for revision,
-selector, projection, retry, and capability details.
-
-## Agent Skill
-
-`skills/agency/SKILL.md` contains an agent-oriented operating guide for Agency.
-Install or link that directory into your agent's skill location when you want
-Agency workflows to be discovered automatically.
+use one error envelope. Revision and concurrency behavior is documented under
+Tasks, Phases, and Claims; selector behavior under Noninteractive Use; projection
+behavior under Target Context and Workbase Graph; and retry behavior in the
+machine error contract above.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markjaquith/agency",
-  "version": "2.47.3",
+  "version": "2.48.1",
   "description": "Manage agentic work across repositories with durable workbases",
   "keywords": [
     "agents",
@@ -23,7 +23,6 @@
     "src",
     "schemas",
     "fixtures/protocol",
-    "skills",
     "README.md",
     "LICENSE"
   ],

package/src/cli-parser.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
 import orchestrationRecipes from "../fixtures/protocol/orchestration-recipes.json"
-import skillSetupCommands from "../fixtures/protocol/skill-setup-commands.json"
 import { parseCli } from "./cli-parser"
 
 const expectUsageError = (args: string[], usage: string) => {
@@ -14,12 +13,6 @@ describe("strict CLI parsing", () => {
 		}
 	})
 
-	test("accepts every documented skill setup command", () => {
-		for (const args of skillSetupCommands) {
-			expect(() => parseCli(args)).not.toThrow()
-		}
-	})
-
 	test("rejects misspelled and command-inapplicable options", () => {
 		expectUsageError(["task", "list", "--josn"], "agency task")
 		expectUsageError(

package/src/cli.test.ts

@@ -526,7 +526,6 @@ describe("CLI", () => {
 		expect(before.files).toMatchObject([
 			{ name: "agents", state: "managed" },
 			{ name: "opencode", state: "managed" },
-			{ name: "opencode-command", state: "managed" },
 			{ name: "opencode-plugin", state: "managed" },
 			{ name: "opencode-tui", state: "managed" },
 			{ name: "opencode-tui-plugin", state: "managed" },
@@ -538,7 +537,6 @@ describe("CLI", () => {
 		expect(synced.files).toMatchObject([
 			{ name: "agents", state: "managed", changed: false },
 			{ name: "opencode", state: "managed", changed: false },
-			{ name: "opencode-command", 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 },
@@ -1022,7 +1020,7 @@ status: open
 				},
 				{
 					args: ["--task", "pipeline", "--phase", "build"],
-					cwd: join(workbaseRoot, "tasks/pipeline"),
+					cwd: join(workbaseRoot, "tasks/pipeline/phases/build"),
 					checkoutPath: join(
 						workbaseRoot,
 						"tasks/pipeline/phases/build/code/agency",
@@ -1060,6 +1058,16 @@ status: open
 					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,

package/src/commands/init.test.ts

@@ -34,7 +34,11 @@ describe("init command", () => {
 			"/repos/\n/tasks/*/code/\n/tasks/*/phases/*/code/\n",
 		)
 		expect(await Bun.file(join(root, "AGENTS.md")).exists()).toBe(false)
-		expect(await Bun.file(join(root, ".agency/AGENTS.md")).exists()).toBe(true)
+		const agents = await Bun.file(join(root, ".agency/AGENTS.md")).text()
+		expect(agents).toContain("agency context . --json")
+		expect(agents).toContain("## Consent Boundaries")
+		expect(agents).toContain("## Execution")
+		expect(agents).not.toContain("SKILL.md")
 		const opencode = await Bun.file(
 			join(root, ".opencode/opencode.jsonc"),
 		).text()
@@ -64,11 +68,9 @@ describe("init command", () => {
 			workbase: expect.objectContaining({ path: ".." }),
 		})
 		expect(config.permission).toBeUndefined()
-		const command = await Bun.file(
-			join(root, ".opencode/command/agency.md"),
-		).text()
-		expect(command).toContain("Workflow: `$1`")
-		expect(command).toContain("Optional target: `$2`")
+		expect(
+			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
+		).toBe(false)
 		const plugin = await Bun.file(
 			join(root, ".opencode/plugin/agency-repository-skills.ts"),
 		).text()

package/src/commands/integration.test.ts

@@ -36,11 +36,6 @@ describe("integration command", () => {
 					diagnostic: expect.stringContaining("cannot load"),
 					remediation: expect.stringContaining("integration sync"),
 				},
-				{
-					name: "opencode-command",
-					state: "missing",
-					remediation: expect.stringContaining("integration sync"),
-				},
 				{
 					name: "opencode-plugin",
 					state: "missing",
@@ -91,11 +86,6 @@ OpenCode config: missing
   Agency OpenCode launches cannot load current Agency instructions or whole-workbase access.
   Action: Run 'agency integration sync' to install Agency instructions and whole-workbase OpenCode access.
 
-OpenCode /agency command: missing
-  Path: .opencode/command/agency.md
-  The managed OpenCode /agency command needs synchronization.
-  Action: Run 'agency integration sync' to install the managed /agency command.
-
 OpenCode workbase plugin: missing
   Path: .opencode/plugin/agency-repository-skills.ts
   The managed OpenCode workbase plugin needs synchronization.
@@ -120,7 +110,6 @@ OpenCode /agency-debug: missing
 		expect(JSON.parse(logs[0]!).files).toMatchObject([
 			{ name: "agents", state: "managed", changed: true },
 			{ name: "opencode", state: "managed", changed: true },
-			{ name: "opencode-command", 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 },
@@ -132,7 +121,7 @@ OpenCode /agency-debug: missing
 		).toBe(true)
 		expect(
 			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(true)
+		).toBe(false)
 		expect(
 			await Bun.file(
 				join(root, ".opencode/plugin/agency-repository-skills.ts"),
@@ -161,10 +150,6 @@ OpenCode config: synced
   Path: .opencode/opencode.jsonc
   Agency's managed OpenCode launch config is ready to load Agency instructions and provide whole-workbase read access.
 
-OpenCode /agency command: synced
-  Path: .opencode/command/agency.md
-  Agency's managed OpenCode /agency command is current.
-
 OpenCode workbase plugin: synced
   Path: .opencode/plugin/agency-repository-skills.ts
   Agency's managed OpenCode plugin provides whole-workbase access and exposes writable-checkout skills.

package/src/commands/integration.ts

@@ -15,7 +15,6 @@ interface IntegrationResult {
 		readonly name:
 			| "agents"
 			| "opencode"
-			| "opencode-command"
 			| "opencode-plugin"
 			| "opencode-tui"
 			| "opencode-tui-plugin"
@@ -30,7 +29,6 @@ interface IntegrationResult {
 const integrationNames = {
 	agents: "Agent instructions",
 	opencode: "OpenCode config",
-	"opencode-command": "OpenCode /agency command",
 	"opencode-plugin": "OpenCode workbase plugin",
 	"opencode-tui": "OpenCode TUI config",
 	"opencode-tui-plugin": "OpenCode /agency-debug",

package/src/commands/work.test.ts

@@ -45,6 +45,8 @@ const multiPhaseWorkspace: ExecutionWorkspace = {
 }
 
 const taskDirectory = "/workbase/tasks/example"
+const phaseDirectory = `${taskDirectory}/phases/implementation`
+
 interface HarnessOptions {
 	readonly workspace?: ExecutionWorkspace
 	readonly materializeError?: Error
@@ -563,7 +565,7 @@ describe("work command", () => {
 				"--prompt",
 				"Start the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
 			],
-			cwd: taskDirectory,
+			cwd: phaseDirectory,
 		})
 		expect(harness.statusUpdates).toEqual([
 			"phase:example:implementation:working",
@@ -593,7 +595,11 @@ describe("work command", () => {
 			data: {},
 		}
 		const harness = createHarness({
-			workspace: multiPhaseWorkspace,
+			workspace: {
+				...multiPhaseWorkspace,
+				taskPath: "/workbase/tasks/delivery/TASK.md",
+				phasePath: "/workbase/tasks/delivery/phases/build/PHASE.md",
+			},
 			taskRecords: [
 				{
 					id: "delivery",
@@ -615,7 +621,9 @@ describe("work command", () => {
 			"probe:opencode",
 			"launch:opencode",
 		])
-		expect(harness.launches[0]?.cwd).toBe(taskDirectory)
+		expect(harness.launches[0]?.cwd).toBe(
+			"/workbase/tasks/delivery/phases/build",
+		)
 	})
 
 	test("requires an explicit target when input is disabled", async () => {
@@ -767,6 +775,18 @@ describe("work command", () => {
 		])
 	})
 
+	test("launches OpenCode in the phase directory with explicit context", async () => {
+		const harness = createHarness({ workspace: multiPhaseWorkspace })
+
+		await harness.run({
+			taskId: "example",
+			phaseId: "implementation",
+			opencode: true,
+		})
+
+		expect(harness.launches[0]?.cwd).toBe(phaseDirectory)
+	})
+
 	test("sends the generated prompt only with --auto", async () => {
 		const harness = createHarness()
 
@@ -820,7 +840,7 @@ describe("work command", () => {
 				"--prompt",
 				"Continue the task. Read /workbase/tasks/example/TASK.md and /workbase/tasks/example/phases/implementation/PHASE.md.",
 			],
-			cwd: taskDirectory,
+			cwd: phaseDirectory,
 		})
 	})
 
@@ -897,6 +917,20 @@ describe("work command", () => {
 		expect(printed.environment.API_TOKEN).toBeUndefined()
 	})
 
+	test("prints the phase directory in the command contract", async () => {
+		const harness = createHarness({ workspace: multiPhaseWorkspace })
+		const output = await captureLogs(() =>
+			harness.run({
+				taskId: "example",
+				phaseId: "implementation",
+				opencode: true,
+				printCommand: true,
+			}),
+		)
+
+		expect(JSON.parse(output.join("\n")).cwd).toBe(phaseDirectory)
+	})
+
 	test("does not reopen a forced terminal target in print-only mode", async () => {
 		const harness = createHarness({ taskStatuses: { example: "done" } })
 

package/src/commands/work.ts

@@ -261,7 +261,7 @@ export const work = (
 			prompt = workspace.phasePath
 				? `${action} the task. Read ${workspace.taskPath} and ${workspace.phasePath}.`
 				: `${action} the task. Read ${workspace.taskPath}.`
-			launchPath = dirname(workspace.taskPath)
+			launchPath = dirname(workspace.phasePath ?? workspace.taskPath)
 			writablePath = workspace.writablePath
 		}
 

package/src/services/IntegrationService.test.ts

@@ -6,10 +6,6 @@ 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 {
-	canUpdateManagedWorkbaseOpencodeCommand,
-	managedWorkbaseOpencodeCommand,
-} from "../workbase/opencode-command-file"
 import { managedWorkbaseOpencode } from "../workbase/opencode-file"
 import {
 	canUpdateManagedWorkbaseOpencodePlugin,
@@ -36,6 +32,12 @@ const managed = (prefix: string, body: string, suffix = "") => {
 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))),
@@ -63,17 +65,11 @@ describe("IntegrationService", () => {
 			"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/command/agency.md",
-			managedWorkbaseOpencodeCommand,
-		)
 		await write(
 			root,
 			".opencode/plugin/agency-repository-skills.ts",
@@ -91,7 +87,6 @@ describe("IntegrationService", () => {
 			"managed",
 			"managed",
 			"managed",
-			"managed",
 		])
 	})
 
@@ -109,7 +104,6 @@ describe("IntegrationService", () => {
 			"missing",
 			"missing",
 			"missing",
-			"missing",
 		])
 	})
 
@@ -257,43 +251,25 @@ describe("IntegrationService", () => {
 		).toBe(true)
 	})
 
-	test("generates a positional OpenCode command for Agency workflows", () => {
-		expect(managedWorkbaseOpencodeCommand).toContain(
-			"description: Operate Agency work",
-		)
-		expect(managedWorkbaseOpencodeCommand).toContain("Workflow: `$1`")
-		expect(managedWorkbaseOpencodeCommand).toContain("Optional target: `$2`")
-		expect(managedWorkbaseOpencodeCommand).toContain(
-			"Complete request: `$ARGUMENTS`",
-		)
-		for (const workflow of [
-			"start",
-			"status",
-			"next",
-			"validate",
-			"finish",
-			"help",
-		]) {
-			expect(managedWorkbaseOpencodeCommand).toContain(`- \`${workflow}\`:`)
-		}
-		expect(managedWorkbaseOpencodeCommand).toContain("Never run `agency work`")
-		expect(
-			canUpdateManagedWorkbaseOpencodeCommand(managedWorkbaseOpencodeCommand),
-		).toBe(true)
-		expect(
-			canUpdateManagedWorkbaseOpencodeCommand(
-				managedWorkbaseOpencodeCommand.replace("Workflow: `$1`", "Workflow"),
-			),
-		).toBe(false)
-	})
-
 	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("`agency work` is the local launch flow")
-		expect(body).toContain("External orchestrators claim before launching")
+		expect(body).toContain("Only `done` satisfies a dependency")
+		expect(body).toContain("Require explicit user intent")
+		expect(body).toContain("changing repository")
+		expect(body).toMatch(/archiving, restoring,\s+dropping, or/)
+		expect(body).toContain("Never invent entity IDs")
+		expect(body).toContain("Preserve parent backlinks")
+		expect(body).toContain("dirty-worktree, active-claim, revision")
+		expect(body).toContain("`agency work` is the human launch flow")
+		expect(body).toContain("marks execution work")
+		expect(body).toContain("without creating a claim")
+		expect(body).toContain("formatting, type checks, build, dead-code checks")
+		expect(body).toContain("Review and commit the diff")
 		expect(body).toContain("Run `agency validate`")
 		expect(body).toContain("only with explicit user intent")
 		expect(body).toContain("An execution unit remains `working`")
@@ -309,7 +285,9 @@ describe("IntegrationService", () => {
 		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).toContain(".opencode/command/agency.md")
+		expect(body).not.toContain("SKILL.md")
+		expect(body).not.toContain("~/.agents")
+		expect(body).not.toContain(".opencode/command/agency.md")
 	})
 
 	test("configures Agency agents with complete workbase access", () => {
@@ -440,7 +418,6 @@ describe("IntegrationService", () => {
 		expect(first.files).toMatchObject([
 			{ name: "agents", state: "customized", changed: false },
 			{ name: "opencode", state: "managed", changed: true },
-			{ name: "opencode-command", 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 },
@@ -455,8 +432,8 @@ describe("IntegrationService", () => {
 			managedWorkbaseOpencode,
 		)
 		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).text(),
-		).toBe(managedWorkbaseOpencodeCommand)
+			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
+		).toBe(false)
 		expect(
 			await Bun.file(
 				join(root, ".opencode/plugin/agency-repository-skills.ts"),
@@ -480,12 +457,37 @@ describe("IntegrationService", () => {
 		)
 	})
 
+	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[3]).toMatchObject({
+		expect(result.files[2]).toMatchObject({
 			name: "opencode-plugin",
 			path: join(root, ".opencode/plugins/agency-repository-skills.ts"),
 			state: "customized",
@@ -500,7 +502,7 @@ describe("IntegrationService", () => {
 		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[3]).toMatchObject({
+		expect(result.files[2]).toMatchObject({
 			path: join(root, ".opencode/plugin/agency-repository-skills.ts"),
 			state: "customized",
 			changed: false,
@@ -515,14 +517,14 @@ describe("IntegrationService", () => {
 		await write(root, ".opencode/tui/agency-debug.ts", customPlugin)
 
 		const result = await sync(root)
-		expect(result.files[4]).toMatchObject({
+		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[5]).toMatchObject({
+		expect(result.files[4]).toMatchObject({
 			name: "opencode-tui-plugin",
 			state: "customized",
 			changed: false,
@@ -535,32 +537,23 @@ describe("IntegrationService", () => {
 		).toBe(customPlugin)
 	})
 
-	test("preserves user-owned OpenCode commands at either supported path", async () => {
-		const custom = "---\ndescription: Custom Agency command\n---\n\nCustom.\n"
-		await write(root, ".opencode/commands/agency.md", custom)
+	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)
 
-		let result = await sync(root)
-		expect(result.files[2]).toMatchObject({
-			name: "opencode-command",
-			path: join(root, ".opencode/commands/agency.md"),
-			state: "customized",
-			changed: false,
-		})
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).exists(),
-		).toBe(false)
+		await status(root)
+		expect(await Bun.file(join(root, path)).text()).toBe(legacy)
 
-		await unlink(join(root, ".opencode/commands/agency.md"))
-		await write(root, ".opencode/command/agency.md", custom)
-		result = await sync(root)
-		expect(result.files[2]).toMatchObject({
-			path: join(root, ".opencode/command/agency.md"),
-			state: "customized",
-			changed: false,
-		})
-		expect(
-			await Bun.file(join(root, ".opencode/command/agency.md")).text(),
-		).toBe(custom)
+		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 () => {