@markjaquith/agency 2.48.0 → 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,10 +83,11 @@ 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
@@ -122,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,

package/package.json

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

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

@@ -68,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,36 +251,6 @@ 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)
 
@@ -323,7 +287,7 @@ describe("IntegrationService", () => {
 		expect(body).toContain("agency integration status")
 		expect(body).not.toContain("SKILL.md")
 		expect(body).not.toContain("~/.agents")
-		expect(body).toContain(".opencode/command/agency.md")
+		expect(body).not.toContain(".opencode/command/agency.md")
 	})
 
 	test("configures Agency agents with complete workbase access", () => {
@@ -454,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 },
@@ -469,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"),
@@ -524,7 +487,7 @@ describe("IntegrationService", () => {
 		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",
@@ -539,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,
@@ -554,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,
@@ -574,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 () => {

package/src/services/IntegrationService.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect"
+import { createHash } from "node:crypto"
 import { join } from "node:path"
 import { FileSystemService } from "./FileSystemService"
 import { WorkbaseService } from "./WorkbaseService"
@@ -10,10 +11,6 @@ import {
 	canUpdateManagedWorkbaseOpencode,
 	managedWorkbaseOpencode,
 } from "../workbase/opencode-file"
-import {
-	canUpdateManagedWorkbaseOpencodeCommand,
-	managedWorkbaseOpencodeCommand,
-} from "../workbase/opencode-command-file"
 import {
 	canUpdateManagedWorkbaseOpencodePlugin,
 	managedWorkbaseOpencodePlugin,
@@ -33,7 +30,6 @@ interface IntegrationFileStatus {
 	readonly name:
 		| "agents"
 		| "opencode"
-		| "opencode-command"
 		| "opencode-plugin"
 		| "opencode-tui"
 		| "opencode-tui-plugin"
@@ -74,25 +70,6 @@ const describe = (
 				"Run 'agency integration sync' to install Agency instructions and whole-workbase OpenCode access.",
 		}
 	}
-	if (name === "opencode-command") {
-		return state === "managed"
-			? {
-					diagnostic: "Agency's managed OpenCode /agency command is current.",
-					remediation: null,
-				}
-			: state === "customized"
-				? {
-						diagnostic:
-							"A user-owned OpenCode /agency command is present and was preserved.",
-						remediation: null,
-					}
-				: {
-						diagnostic:
-							"The managed OpenCode /agency command needs synchronization.",
-						remediation:
-							"Run 'agency integration sync' to install the managed /agency command.",
-					}
-	}
 	if (name === "opencode-plugin") {
 		return state === "managed"
 			? {
@@ -202,8 +179,6 @@ const inspect = (root: string) =>
 		const opencodeJsonPath = join(opencodeDirectory, "opencode.json")
 		const tuiPath = join(opencodeDirectory, "tui.jsonc")
 		const tuiJsonPath = join(opencodeDirectory, "tui.json")
-		const commandPath = join(opencodeDirectory, "command", "agency.md")
-		const pluralCommandPath = join(opencodeDirectory, "commands", "agency.md")
 		const pluginPath = join(
 			opencodeDirectory,
 			"plugin",
@@ -252,29 +227,6 @@ const inspect = (root: string) =>
 			files.push(fileStatus("opencode", opencodePath, "missing"))
 		}
 
-		if ((yield* fs.readSymlinkTarget(commandPath)) !== null) {
-			files.push(fileStatus("opencode-command", commandPath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(pluralCommandPath)) !== null ||
-			(yield* fs.exists(pluralCommandPath))
-		) {
-			files.push(
-				fileStatus("opencode-command", pluralCommandPath, "customized"),
-			)
-		} else if (yield* fs.exists(commandPath)) {
-			files.push(
-				classify(
-					"opencode-command",
-					commandPath,
-					yield* fs.readFile(commandPath),
-					managedWorkbaseOpencodeCommand,
-					canUpdateManagedWorkbaseOpencodeCommand,
-				),
-			)
-		} else {
-			files.push(fileStatus("opencode-command", commandPath, "missing"))
-		}
-
 		if ((yield* fs.readSymlinkTarget(pluginPath)) !== null) {
 			files.push(fileStatus("opencode-plugin", pluginPath, "customized"))
 		} else if (
@@ -348,6 +300,25 @@ const canRemoveLegacyAgents = (root: string) =>
 		return canUpdateManagedWorkbaseAgents(yield* fs.readFile(path))
 	})
 
+const canRemoveLegacyOpencodeCommand = (root: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const path = join(root, ".opencode", "command", "agency.md")
+		if (
+			(yield* fs.readSymlinkTarget(path)) !== null ||
+			!(yield* fs.exists(path))
+		)
+			return false
+
+		const content = yield* fs.readFile(path)
+		const header = /^---\r?\n# agency-managed: sha256=([a-f0-9]{64})\r?\n/
+		const match = content.match(header)
+		if (!match?.[1]) return false
+
+		const canonical = content.replace(header, "---\n")
+		return createHash("sha256").update(canonical).digest("hex") === match[1]
+	})
+
 export class IntegrationService extends Effect.Service<IntegrationService>()(
 	"IntegrationService",
 	{
@@ -370,6 +341,8 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 							(status) =>
 								status.name === "opencode" && status.state !== "customized",
 						) && (yield* canRemoveLegacyAgents(root))
+					const removeLegacyOpencodeCommand =
+						yield* canRemoveLegacyOpencodeCommand(root)
 					const files: IntegrationSyncFile[] = []
 
 					for (const status of statuses) {
@@ -382,9 +355,6 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 							} else if (status.name === "opencode") {
 								yield* fs.createDirectory(join(root, ".opencode"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencode)
-							} else if (status.name === "opencode-command") {
-								yield* fs.createDirectory(join(root, ".opencode", "command"))
-								yield* fs.writeFile(status.path, managedWorkbaseOpencodeCommand)
 							} else if (status.name === "opencode-plugin") {
 								yield* fs.createDirectory(join(root, ".opencode", "plugin"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencodePlugin)
@@ -411,6 +381,11 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 					}
 
 					if (removeLegacyAgents) yield* fs.deleteFile(join(root, "AGENTS.md"))
+					if (removeLegacyOpencodeCommand) {
+						yield* fs.deleteFile(
+							join(root, ".opencode", "command", "agency.md"),
+						)
+					}
 
 					return { root, files }
 				}),

package/src/workbase/AGENTS.md

@@ -100,15 +100,15 @@ a refinement loop, or pausing or handing off completed implementation work):
 `agency integration status` reports `managed`, `drifted`, `customized`, or
 `missing` generated files. Agency keeps these instructions in
 `.agency/AGENTS.md`, and its managed OpenCode config loads them automatically.
-It also installs `.opencode/command/agency.md`, which provides safe `/agency`
-workflows for active OpenCode sessions, a managed server plugin that exposes
-skills from the authoritative writable checkout, and an explicitly registered
-TUI companion providing `/agency-debug` without submitting an LLM prompt.
+It also installs a managed server plugin that exposes skills from the
+authoritative writable checkout and an explicitly registered TUI companion
+providing `/agency-debug` without submitting an LLM prompt.
 The workbase-root `AGENTS.md`, when present, belongs entirely to the workbase
 owner and composes with these instructions through OpenCode's normal discovery.
 `agency integration sync` updates only missing or checksum-safe drifted managed
-files and preserves user-customized files. `agency init` creates the managed
-files, and `agency work` reconciles them before launching an agent.
+files, removes checksum-valid retired artifacts, and preserves user-customized
+files. `agency init` creates the managed files, and `agency work` reconciles them
+before launching an agent.
 
 OpenCode can access the complete workbase tree, but this filesystem permission
 does not expand Agency write authority beyond the checkout reported by

package/src/workbase/AGENCY_COMMAND.md

@@ -1,48 +0,0 @@
----
-description: Operate Agency work with safe start, status, next, validate, and finish workflows
----
-
-Operate the current Agency workbase using the managed Agency instructions.
-
-Invocation inputs:
-
-- Workflow: `$1`
-- Optional target: `$2`
-- Complete request: `$ARGUMENTS`
-
-Use `status` when the workflow is empty. Treat words after the optional target as
-additional user instructions. If the workflow is unknown, make no changes and
-list the supported workflows.
-
-Always follow these rules:
-
-- Run `agency context . --json` first when no target is provided. With a target,
-  pass that target to `agency context` instead.
-- Use the returned document paths, readiness, authority, checkout state, claim,
-  and validation result. Do not infer them from directory names.
-- Stop on validation errors, dependency blockers, an unexpected writable
-  repository, or a conflicting active claim.
-- Write code only in `authority.writable.checkoutPath`; references are read-only.
-- Never run `agency work` to start the current agent again.
-- Create a pull request only when the complete request explicitly asks for one.
-
-Dispatch the workflow as follows:
-
-- `start`: Read the returned task and phase documents, inspect the writable
-  checkout, then begin or resume the requested work in this session. Keep durable
-  decisions current and carry the work through focused verification.
-- `status`: Make no changes. Summarize the target, readiness, authority, durable
-  status, claim and PR state, checkout state, current Git changes, blockers, and
-  the most useful next action.
-- `next`: Run `agency next --json`, summarize ready and blocked execution units,
-  and recommend the highest-priority ready unit. Do not launch another agent.
-- `validate`: Run Agency validation for the discovered workbase. Explain every
-  issue and, when safe and within authority, repair requested non-structural
-  problems before validating again.
-- `finish`: Complete any remaining requested implementation first. Run focused
-  repository checks, refresh the task or phase delivery context, and run
-  `agency validate`. Finish an active claim with its current revision; otherwise
-  update unclaimed status only when the requested outcome and delivery work are
-  actually complete. Do not create a PR unless explicitly requested.
-- `help`: Make no changes. Briefly explain these workflows and the positional
-  form `/agency <workflow> [target] [additional instructions]`.

package/src/workbase/opencode-command-file.ts

@@ -1,30 +0,0 @@
-import { createHash } from "node:crypto"
-import commandTemplate from "./AGENCY_COMMAND.md" with { type: "text" }
-
-const managedHeaderPattern =
-	/^---\r?\n# agency-managed: sha256=([a-f0-9]{64})\r?\n/
-
-const checksum = (content: string) =>
-	createHash("sha256").update(content).digest("hex")
-
-const canonicalBody = commandTemplate.endsWith("\n")
-	? commandTemplate
-	: `${commandTemplate}\n`
-
-const renderManagedWorkbaseOpencodeCommand = (
-	content: string = canonicalBody,
-) =>
-	content.replace(
-		/^---\n/,
-		`---\n# agency-managed: sha256=${checksum(content)}\n`,
-	)
-
-export const managedWorkbaseOpencodeCommand =
-	renderManagedWorkbaseOpencodeCommand()
-
-export const canUpdateManagedWorkbaseOpencodeCommand = (content: string) => {
-	const match = content.match(managedHeaderPattern)
-	if (!match?.[1]) return false
-
-	return checksum(content.replace(managedHeaderPattern, "---\n")) === match[1]
-}