@markjaquith/agency 2.48.0 → 2.49.0

package/src/commands/task.ts

@@ -38,6 +38,9 @@ interface TaskOptions extends BaseCommandOptions {
 	readonly pr?: boolean
 	readonly work?: boolean
 	readonly auto?: boolean
+	readonly noPullRequest?: boolean
+	readonly summary?: string
+	readonly evidenceUrl?: string
 }
 
 export interface TaskInteraction {
@@ -304,7 +307,19 @@ export const task = (
 						new Error("Usage: agency task status <id> <status>"),
 					)
 				}
-				const record = yield* tasks.setStatus(id, status, cwd)
+				const record = yield* tasks.setStatus(
+					id,
+					status,
+					cwd,
+					options.noPullRequest
+						? {
+								summary: options.summary ?? "",
+								...(options.evidenceUrl
+									? { evidenceUrl: options.evidenceUrl }
+									: {}),
+							}
+						: undefined,
+				)
 				const { content: _, ...output } = record
 				log(
 					options.json
@@ -423,7 +438,7 @@ Subcommands:
   create <id>           Create a task without prompting
   list                  List tasks
   show <id>             Show a task
-  status <id> <status>  Set open, working, or dropped
+  status <id> <status>  Set open, working, dropped, or explicit non-PR done
   update <id>           Update task metadata
   rename <id> <new-id>  Rename a task and update graph references
   move <id>             Move a task with --epic or --no-epic
@@ -433,6 +448,11 @@ Subcommands:
 Mutation option:
   --if-revision <hash>  Require the target's current revision
 
+Non-PR completion options (status done only):
+  --no-pull-request     Complete without a pull request
+  --summary <text>      Required durable outcome summary
+  --evidence-url <url>  Optional supporting record
+
 Create options:
   --ticket-url <url>    External ticket URL (optional)
   --description <text>  Short description of the task

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/ClaimService.test.ts

@@ -147,6 +147,65 @@ describe("claim service", () => {
 		})
 	})
 
+	test("finishes claimed non-PR work with durable completion evidence", async () => {
+		const initial = await inspect()
+		const acquired = await claim(initial.revision)
+		const finished = await runTestEffect(
+			ClaimService.pipe(
+				Effect.flatMap((service) =>
+					service.finish(
+						{
+							taskId: "single",
+							sessionId: "session-1",
+							revision: acquired.revision,
+							outcome: "done",
+							nonPrCompletion: {
+								summary: "Review completed; no code change was needed.",
+								evidenceUrl: "https://example.com/review",
+							},
+							now: at("2026-07-17T12:45:00.000Z"),
+						},
+						root,
+					),
+				),
+			),
+		)
+
+		expect(finished.data).toMatchObject({
+			status: "done",
+			claim: { state: "finished", outcome: "done" },
+			completion: {
+				mode: "non-pr",
+				completedAt: "2026-07-17T12:45:00.000Z",
+				summary: "Review completed; no code change was needed.",
+				evidenceUrl: "https://example.com/review",
+			},
+		})
+	})
+
+	test("rejects invalid claimed non-PR completion", async () => {
+		const initial = await inspect()
+		const acquired = await claim(initial.revision)
+		await expect(
+			runTestEffect(
+				ClaimService.pipe(
+					Effect.flatMap((service) =>
+						service.finish(
+							{
+								taskId: "single",
+								sessionId: "session-1",
+								revision: acquired.revision,
+								outcome: "done",
+								nonPrCompletion: { summary: " " },
+							},
+							root,
+						),
+					),
+				),
+			),
+		).rejects.toThrow("summary must not be empty")
+	})
+
 	test("returns structured ownership and revision conflicts", async () => {
 		const initial = await inspect()
 		const acquired = await claim(initial.revision)

package/src/services/ClaimService.ts

@@ -31,6 +31,10 @@ import {
 	type PhaseFrontmatter as PhaseData,
 	type TaskFrontmatter as TaskData,
 } from "../workbase/schemas"
+import {
+	buildNonPrCompletion,
+	type NonPrCompletionInput,
+} from "../workbase/completion"
 
 class ClaimError extends Data.TaggedError("ClaimError")<{
 	readonly message: string
@@ -83,6 +87,7 @@ interface OwnedClaimInput {
 
 interface FinishInput extends OwnedClaimInput {
 	readonly outcome: "done" | "dropped"
+	readonly nonPrCompletion?: NonPrCompletionInput
 }
 
 interface ExpireClaimInput {
@@ -507,6 +512,11 @@ export class ClaimService extends Effect.Service<ClaimService>()(
 			finish: (input: FinishInput, startPath: string = process.cwd()) =>
 				Effect.gen(function* () {
 					assertIdentity("Session ID", input.sessionId)
+					if (input.nonPrCompletion && input.outcome !== "done") {
+						return yield* new ClaimError({
+							message: "Non-PR completion is valid only with a done outcome",
+						})
+					}
 					const service = yield* ClaimService
 					const inspected = yield* service.inspect(
 						input.taskId,
@@ -531,6 +541,22 @@ export class ClaimService extends Effect.Service<ClaimService>()(
 										message: `Session '${input.sessionId}' does not own ${inspected.target.label}`,
 									})
 								}
+								if (input.nonPrCompletion && data.pr !== null) {
+									throw new ClaimError({
+										target: inspected.target.label,
+										message:
+											"Cannot complete without a pull request while an authoritative pull request is recorded",
+									})
+								}
+								const completionResult = input.nonPrCompletion
+									? buildNonPrCompletion(input.nonPrCompletion, now)
+									: undefined
+								if (completionResult && "error" in completionResult) {
+									throw new ClaimError({
+										target: inspected.target.label,
+										message: completionResult.error,
+									})
+								}
 								const claim: ClaimRecord = {
 									...data.claim,
 									state: "finished",
@@ -540,8 +566,15 @@ export class ClaimService extends Effect.Service<ClaimService>()(
 								return {
 									data: {
 										...data,
-										status: input.outcome === "done" ? "working" : "dropped",
+										status: completionResult
+											? "done"
+											: input.outcome === "done"
+												? "working"
+												: "dropped",
 										claim,
+										...(completionResult
+											? { completion: completionResult.value }
+											: {}),
 									},
 									claim,
 								}

package/src/services/GraphMutationService.ts

@@ -374,6 +374,16 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 							message: `Task '${id}' has an active claim; release or finish it before changing execution metadata`,
 						})
 					}
+					if (
+						updates.pr &&
+						"completion" in record.data &&
+						record.data.completion
+					) {
+						return yield* new GraphMutationError({
+							message:
+								"Reopen non-PR completed work before recording a pull request",
+						})
+					}
 					if (
 						executionChange &&
 						(yield* fs.isDirectory(join(dirname(record.path), "code")))
@@ -504,6 +514,12 @@ export class GraphMutationService extends Effect.Service<GraphMutationService>()
 							message: `Phase '${id}' has an active claim; release or finish it before changing execution metadata`,
 						})
 					}
+					if (updates.pr && record.data.completion) {
+						return yield* new GraphMutationError({
+							message:
+								"Reopen non-PR completed work before recording a pull request",
+						})
+					}
 					const data: PhaseData = yield* decode(
 						PhaseFrontmatter,
 						{

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)
 
@@ -297,7 +261,9 @@ describe("IntegrationService", () => {
 		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).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, active-claim, revision")
@@ -317,13 +283,14 @@ describe("IntegrationService", () => {
 		expect(body).toContain("pausing or handing off")
 		expect(body).toContain("`agency finish`")
 		expect(body).toContain("`agency sync --apply`")
+		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).toContain(".opencode/command/agency.md")
+		expect(body).not.toContain(".opencode/command/agency.md")
 	})
 
 	test("configures Agency agents with complete workbase access", () => {
@@ -454,7 +421,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 +435,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 +490,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 +505,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 +520,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 +540,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 }
 				}),