@markjaquith/agency 2.65.2 → 2.67.0

package/README.md

@@ -54,7 +54,7 @@ workbase/
   .opencode/
     opencode.jsonc         # managed @agency subagent, instructions, and reference
     tui.jsonc              # managed TUI plugin registration
-    plugin/agency-repository-skills.ts # managed workbase access and checkout skills
+    plugins/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
   repos/                   # ignored local materializations
@@ -119,6 +119,9 @@ toast and does not submit a prompt to an LLM. When no writable checkout skill
 directory is available, server initialization is reported as indeterminate
 rather than inferred from plugin discovery.
 OpenCode discovers the config and plugin from task and epic launch directories.
+The plugin uses OpenCode's plural discovery directory and exports both the V1
+server function and the `opencode2` module wrapper. Integration sync migrates a
+checksum-valid legacy singular-path plugin and preserves customized files.
 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`.
@@ -347,8 +350,10 @@ external effects the failed invocation may have completed.
 
 ### Agent Runners
 
-OpenCode and Claude Code are built-in runner presets. Select either preset or a
-configured runner with `agency work --runner <name>`. A launch is fresh unless
+OpenCode (`opencode2` and `opencode`) and Claude Code are built-in runner presets.
+Without an explicit runner, Agency uses the first available executable in this
+order: `opencode2`, `opencode`, then `claude`. Select a preset or configured
+runner with `agency work --runner <name>`. A launch is fresh unless
 `AGENCY_SESSION_ID` is already set; resumed launches use the runner's
 `resumeCommand` when configured. The built-in presets use `--continue` only for
 resumed launches. By default Agency opens the runner without a prompt. `--auto`
@@ -399,8 +404,9 @@ to the receiving OpenCode session, injects an explicit active-worker system
 instruction, and restores Agency identity for that session's shell environment.
 This session bridge is necessary because an OpenCode client can attach to a
 long-lived server process that did not inherit the client's launch environment.
-The `opencode` runner remains rooted in its task or epic working directory so
-the workbase `AGENTS.md` and managed OpenCode config are discovered normally.
+The `opencode2` and `opencode` runners remain rooted in their task or epic
+working directory so the workbase `AGENTS.md` and managed OpenCode config are
+discovered normally.
 Agency's managed OpenCode plugin grants the active workbase external-directory
 access and adds existing checkout-local `.claude/skills`, `.agents/skills`, and
 `.opencode/{skill,skills}` directories to `skills.paths`.
@@ -1063,10 +1069,10 @@ configured external chooser. Pass a directory, including `.` for the current
 directory, to infer its epic, task, or phase. Outside a workbase, Agency first
 presents the registered workbases, then the selected workbase's hierarchy.
 
-OpenCode is the default runner, with automatic Claude fallback when neither is
-explicitly selected. `--opencode` and `--claude` remain aliases for requiring
-their built-in presets. Launches are interactive and promptless by default; use
-`--auto` to send Agency's generated context prompt.
+Agency automatically uses the first available runner in this order: `opencode2`,
+`opencode`, then `claude`. `--opencode` and `--claude` remain aliases for
+requiring their corresponding built-in presets. Launches are interactive and
+promptless by default; use `--auto` to send Agency's generated context prompt.
 
 `agency work prepare` resolves an execution unit and creates or reuses its
 writable and reference worktrees, or its single pinned review checkout, without

package/package.json

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

package/src/commands/init.test.ts

@@ -74,7 +74,7 @@ describe("init command", () => {
 			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"),
+			join(root, ".opencode/plugins/agency-repository-skills.ts"),
 		).text()
 		expect(plugin).toContain("AGENCY_WRITABLE_CHECKOUT")
 		expect(plugin).toContain("config.skills.paths")

package/src/commands/integration.test.ts

@@ -87,7 +87,7 @@ OpenCode config: missing
   Action: Run 'agency integration sync' to install Agency instructions and whole-workbase OpenCode access.
 
 OpenCode workbase plugin: missing
-  Path: .opencode/plugin/agency-repository-skills.ts
+  Path: .opencode/plugins/agency-repository-skills.ts
   The managed OpenCode workbase plugin needs synchronization.
   Action: Run 'agency integration sync' to provide workbase access and expose writable-checkout skills in OpenCode.
 
@@ -124,7 +124,7 @@ OpenCode /agency-debug: missing
 		).toBe(false)
 		expect(
 			await Bun.file(
-				join(root, ".opencode/plugin/agency-repository-skills.ts"),
+				join(root, ".opencode/plugins/agency-repository-skills.ts"),
 			).exists(),
 		).toBe(true)
 		expect(await Bun.file(join(root, ".opencode/tui.jsonc")).exists()).toBe(
@@ -151,7 +151,7 @@ OpenCode config: synced
   Agency's managed OpenCode launch config is ready to load Agency instructions and provide whole-workbase read access.
 
 OpenCode workbase plugin: synced
-  Path: .opencode/plugin/agency-repository-skills.ts
+  Path: .opencode/plugins/agency-repository-skills.ts
   Agency's managed OpenCode plugin provides whole-workbase access and exposes writable-checkout skills.
 
 OpenCode TUI config: synced

package/src/commands/work.test.ts

@@ -1050,18 +1050,45 @@ describe("work command", () => {
 		).toBeUndefined()
 	})
 
-	test("automatically falls back to Claude", async () => {
-		const harness = createHarness({ available: { opencode: false } })
+	test("automatically prefers opencode2", async () => {
+		const harness = createHarness()
+
+		await harness.run({ taskId: "example" })
+
+		expect(harness.probes).toEqual(["opencode2"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode2",
+			args: ["opencode2"],
+			cwd: taskDirectory,
+		})
+	})
+
+	test("automatically falls back from opencode2 to opencode", async () => {
+		const harness = createHarness({ available: { opencode2: false } })
 
 		await harness.run({ taskId: "example" })
 
-		expect(harness.probes).toEqual(["opencode", "claude"])
+		expect(harness.probes).toEqual(["opencode2", "opencode"])
+		expect(harness.launches[0]).toEqual({
+			cli: "opencode",
+			args: ["opencode"],
+			cwd: taskDirectory,
+		})
+	})
+
+	test("automatically falls back from OpenCode to Claude", async () => {
+		const harness = createHarness({
+			available: { opencode2: false, opencode: false },
+		})
+
+		await harness.run({ taskId: "example" })
+
+		expect(harness.probes).toEqual(["opencode2", "opencode", "claude"])
 		expect(harness.launches[0]).toEqual({
 			cli: "claude",
 			args: ["claude"],
 			cwd: taskDirectory,
 		})
-		expect(harness.launchEnvironments[0]?.OPENCODE_CONFIG).toBeUndefined()
 	})
 
 	test("does not fall back when OpenCode is explicitly required", async () => {
@@ -1090,13 +1117,13 @@ describe("work command", () => {
 
 	test("fails when neither agent tool is available", async () => {
 		const harness = createHarness({
-			available: { opencode: false, claude: false },
+			available: { opencode2: false, opencode: false, claude: false },
 		})
 
 		await expect(harness.run({ taskId: "example" })).rejects.toThrow(
 			"claude CLI tool not found",
 		)
-		expect(harness.probes).toEqual(["opencode", "claude"])
+		expect(harness.probes).toEqual(["opencode2", "opencode", "claude"])
 		expect(harness.launches).toEqual([])
 	})
 
@@ -1150,7 +1177,7 @@ describe("work command", () => {
 			verboseHarness.run({ taskId: "example", verbose: true }),
 		)
 		expect(verboseLogs).toEqual([
-			"Launching command: opencode (cwd: /workbase/tasks/example)",
+			"Launching command: opencode2 (cwd: /workbase/tasks/example)",
 		])
 		expect(verboseHarness.materializeOptions[0]?.verbose).toBe(true)
 

package/src/commands/work.ts

@@ -280,10 +280,16 @@ export const work = (
 			options.claude ||
 			process.env.AGENCY_RUNNER,
 		)
-		let runner =
+		const defaultRunners = ["opencode2", "opencode", "claude"] as const
+		let defaultRunnerIndex = 0
+		let runner: string =
 			options.runner ??
 			process.env.AGENCY_RUNNER ??
-			(options.claude ? "claude" : "opencode")
+			(options.claude
+				? "claude"
+				: options.opencode
+					? "opencode"
+					: defaultRunners[defaultRunnerIndex]!)
 		const claimant = process.env.AGENCY_CLAIMANT ?? process.env.USER ?? "agency"
 		const sessionId =
 			process.env.AGENCY_SESSION_ID ?? `${process.pid}-${Date.now()}`
@@ -311,12 +317,12 @@ export const work = (
 		let available = yield* fs.runCommand(["which", cli], {
 			captureOutput: true,
 		})
-		if (
+		while (
 			available.exitCode !== 0 &&
 			!explicitlyRequested &&
-			runner === "opencode"
+			defaultRunnerIndex < defaultRunners.length - 1
 		) {
-			runner = "claude"
+			runner = defaultRunners[++defaultRunnerIndex]!
 			resolved = resolveRunnerCommand(
 				runner,
 				config.runners,
@@ -580,7 +586,8 @@ Launch an agent for an epic, task, or phase. With no directory, select one
 interactively. A positional argument resolves as a directory first, then as a task
 ID. Use '.' for the current directory. Outside a workbase, select a registered
 workbase first. Managed OpenCode launches receive whole-workbase access through
-Agency's project plugin; Agency context remains authoritative for writes.
+Agency's project plugin; Agency context remains authoritative for writes. Automatic
+runner discovery checks opencode2, opencode, then claude.
 
 The prepare subcommand resolves and materializes an execution workspace without
 launching an agent or changing lifecycle status. --dry-run reports planned Git

package/src/services/IntegrationService.test.ts

@@ -72,7 +72,7 @@ describe("IntegrationService", () => {
 		await write(root, ".opencode/opencode.jsonc", managedWorkbaseOpencode)
 		await write(
 			root,
-			".opencode/plugin/agency-repository-skills.ts",
+			".opencode/plugins/agency-repository-skills.ts",
 			managedWorkbaseOpencodePlugin,
 		)
 		await write(root, ".opencode/tui.jsonc", managedWorkbaseOpencodeTui)
@@ -126,6 +126,15 @@ describe("IntegrationService", () => {
 		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"]',
 		)
@@ -276,7 +285,12 @@ describe("IntegrationService", () => {
 				task: "example",
 				phase,
 			})
-			const hooks = await generated.default({ directory: root } as never)
+			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,
 				{
@@ -351,6 +365,52 @@ describe("IntegrationService", () => {
 			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({
@@ -688,7 +748,7 @@ describe("IntegrationService", () => {
 		).toBe(false)
 		expect(
 			await Bun.file(
-				join(root, ".opencode/plugin/agency-repository-skills.ts"),
+				join(root, ".opencode/plugins/agency-repository-skills.ts"),
 			).text(),
 		).toBe(managedWorkbaseOpencodePlugin)
 		expect(await Bun.file(join(root, ".opencode/tui.jsonc")).text()).toBe(
@@ -761,6 +821,35 @@ describe("IntegrationService", () => {
 		})
 	})
 
+	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 =

package/src/services/IntegrationService.ts

@@ -179,12 +179,12 @@ const inspect = (root: string) =>
 		const opencodeJsonPath = join(opencodeDirectory, "opencode.json")
 		const tuiPath = join(opencodeDirectory, "tui.jsonc")
 		const tuiJsonPath = join(opencodeDirectory, "tui.json")
-		const pluginPath = join(
+		const legacyPluginPath = join(
 			opencodeDirectory,
 			"plugin",
 			"agency-repository-skills.ts",
 		)
-		const pluralPluginPath = join(
+		const pluginPath = join(
 			opencodeDirectory,
 			"plugins",
 			"agency-repository-skills.ts",
@@ -229,11 +229,6 @@ const inspect = (root: string) =>
 
 		if ((yield* fs.readSymlinkTarget(pluginPath)) !== null) {
 			files.push(fileStatus("opencode-plugin", pluginPath, "customized"))
-		} else if (
-			(yield* fs.readSymlinkTarget(pluralPluginPath)) !== null ||
-			(yield* fs.exists(pluralPluginPath))
-		) {
-			files.push(fileStatus("opencode-plugin", pluralPluginPath, "customized"))
 		} else if (yield* fs.exists(pluginPath)) {
 			files.push(
 				classify(
@@ -244,6 +239,20 @@ const inspect = (root: string) =>
 					canUpdateManagedWorkbaseOpencodePlugin,
 				),
 			)
+		} else if (
+			(yield* fs.readSymlinkTarget(legacyPluginPath)) !== null ||
+			(yield* fs.exists(legacyPluginPath))
+		) {
+			const legacyContent =
+				(yield* fs.readSymlinkTarget(legacyPluginPath)) === null
+					? yield* fs.readFile(legacyPluginPath)
+					: null
+			files.push(
+				legacyContent !== null &&
+					canUpdateManagedWorkbaseOpencodePlugin(legacyContent)
+					? fileStatus("opencode-plugin", pluginPath, "missing")
+					: fileStatus("opencode-plugin", legacyPluginPath, "customized"),
+			)
 		} else {
 			files.push(fileStatus("opencode-plugin", pluginPath, "missing"))
 		}
@@ -319,6 +328,23 @@ const canRemoveLegacyOpencodeCommand = (root: string) =>
 		return createHash("sha256").update(canonical).digest("hex") === match[1]
 	})
 
+const canRemoveLegacyOpencodePlugin = (root: string) =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystemService
+		const path = join(
+			root,
+			".opencode",
+			"plugin",
+			"agency-repository-skills.ts",
+		)
+		if (
+			(yield* fs.readSymlinkTarget(path)) !== null ||
+			!(yield* fs.exists(path))
+		)
+			return false
+		return canUpdateManagedWorkbaseOpencodePlugin(yield* fs.readFile(path))
+	})
+
 export class IntegrationService extends Effect.Service<IntegrationService>()(
 	"IntegrationService",
 	{
@@ -343,6 +369,8 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 						) && (yield* canRemoveLegacyAgents(root))
 					const removeLegacyOpencodeCommand =
 						yield* canRemoveLegacyOpencodeCommand(root)
+					const removeLegacyOpencodePlugin =
+						yield* canRemoveLegacyOpencodePlugin(root)
 					const files: IntegrationSyncFile[] = []
 
 					for (const status of statuses) {
@@ -356,7 +384,7 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 								yield* fs.createDirectory(join(root, ".opencode"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencode)
 							} else if (status.name === "opencode-plugin") {
-								yield* fs.createDirectory(join(root, ".opencode", "plugin"))
+								yield* fs.createDirectory(join(root, ".opencode", "plugins"))
 								yield* fs.writeFile(status.path, managedWorkbaseOpencodePlugin)
 							} else if (status.name === "opencode-tui") {
 								yield* fs.createDirectory(join(root, ".opencode"))
@@ -376,11 +404,19 @@ export class IntegrationService extends Effect.Service<IntegrationService>()(
 								needsWrite ? "managed" : status.state,
 							),
 							changed:
-								needsWrite || (status.name === "agents" && removeLegacyAgents),
+								needsWrite ||
+								(status.name === "agents" && removeLegacyAgents) ||
+								(status.name === "opencode-plugin" &&
+									removeLegacyOpencodePlugin),
 						})
 					}
 
 					if (removeLegacyAgents) yield* fs.deleteFile(join(root, "AGENTS.md"))
+					if (removeLegacyOpencodePlugin) {
+						yield* fs.deleteFile(
+							join(root, ".opencode", "plugin", "agency-repository-skills.ts"),
+						)
+					}
 					if (removeLegacyOpencodeCommand) {
 						yield* fs.deleteFile(
 							join(root, ".opencode", "command", "agency.md"),

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

@@ -8,7 +8,8 @@ const checksum = (content: string) =>
 
 const body = `import { existsSync, readFileSync } from "node:fs"
 import { dirname, join, resolve, sep } from "node:path"
-import type { Plugin } from "@opencode-ai/plugin"
+import { fileURLToPath } from "node:url"
+import type { Plugin, PluginModule } from "@opencode-ai/plugin/v1"
 
 const workerLaunchPattern = /^Agency worker launch target: ([^.\\s]+)\\./
 
@@ -20,6 +21,20 @@ type AgencyContext = {
   phase?: string
 }
 
+type V2PluginContext = {
+  reference: {
+    transform(callback: (references: {
+      list(): readonly (readonly [string, unknown])[]
+      add(name: string, source: { type: "local"; path: string; description: string }): void
+    }) => void): Promise<unknown>
+  }
+  skill: {
+    transform(callback: (skills: {
+      source(source: { type: "directory"; path: string }): void
+    }) => void): Promise<unknown>
+  }
+}
+
 const contextTarget = (result: Record<string, any>): string | undefined => {
   const target = result.target
   if (target?.kind === "epic") return \`epic:\${target.epicId}\`
@@ -69,6 +84,15 @@ const discoverCheckout = (directory: string, root: string | undefined) => {
   }
 }
 
+const checkoutSkillPaths = (checkout: string | undefined) => checkout
+  ? [
+      join(checkout, ".claude", "skills"),
+      join(checkout, ".agents", "skills"),
+      join(checkout, ".opencode", "skill"),
+      join(checkout, ".opencode", "skills"),
+    ].filter(existsSync)
+  : []
+
 const agencyContext = async (
   directory: string,
   useEnvironmentTarget = true,
@@ -141,12 +165,7 @@ const plugin: Plugin = async ({ directory }) => {
 
       if (!checkout) return
 
-      const paths = [
-        join(checkout, ".claude", "skills"),
-        join(checkout, ".agents", "skills"),
-        join(checkout, ".opencode", "skill"),
-        join(checkout, ".opencode", "skills"),
-      ].filter(existsSync).map((path) => \`\${path}\${sep}.\`)
+      const paths = checkoutSkillPaths(checkout).map((path) => \`\${path}\${sep}.\`)
       if (paths.length === 0) return
 
       config.skills ??= {}
@@ -186,7 +205,31 @@ const plugin: Plugin = async ({ directory }) => {
   }
 }
 
-export default plugin
+export const AgencyPlugin = plugin
+
+const setup = async (context: V2PluginContext) => {
+  const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..")
+  await context.reference.transform((references) => {
+    if (references.list().some(([name]) => name === "workbase")) return
+    references.add("workbase", {
+      type: "local",
+      path: root,
+      description: "Complete Agency workbase context; write authority still comes only from agency context",
+    })
+  })
+
+  const paths = checkoutSkillPaths(process.env.AGENCY_WRITABLE_CHECKOUT)
+  if (paths.length === 0) return
+  await context.skill.transform((skills) => {
+    for (const path of paths) skills.source({ type: "directory", path })
+  })
+}
+
+export default {
+  id: "agency",
+  setup,
+  server: plugin,
+} satisfies PluginModule & { setup: (context: V2PluginContext) => Promise<void> }
 `
 
 const renderManagedWorkbaseOpencodePlugin = (content: string) =>

package/src/workbase/runner-command.test.ts

@@ -19,6 +19,12 @@ const variables = {
 
 describe("runner commands", () => {
 	test("uses promptless interactive commands for built-in presets", () => {
+		expect(
+			resolveRunnerCommand("opencode2", undefined, variables, false).argv,
+		).toEqual(["opencode2"])
+		expect(
+			resolveRunnerCommand("opencode2", undefined, variables, true).argv,
+		).toEqual(["opencode2", "--continue"])
 		expect(
 			resolveRunnerCommand("opencode", undefined, variables, false).argv,
 		).toEqual(["opencode"])
@@ -31,6 +37,12 @@ describe("runner commands", () => {
 	})
 
 	test("uses autonomous commands when a prompt is requested", () => {
+		expect(
+			resolveRunnerCommand("opencode2", undefined, variables, false, true).argv,
+		).toEqual(["opencode2", "--prompt", "Read the task."])
+		expect(
+			resolveRunnerCommand("opencode2", undefined, variables, true, true).argv,
+		).toEqual(["opencode2", "--continue", "--prompt", "Read the task."])
 		expect(
 			resolveRunnerCommand("opencode", undefined, variables, false, true).argv,
 		).toEqual(["opencode", "--prompt", "Read the task."])

package/src/workbase/runner-command.ts

@@ -31,6 +31,12 @@ const PLACEHOLDERS = new Set<keyof RunnerCommandVariables>([
 ])
 
 const BUILTIN_RUNNERS: Readonly<Record<string, RunnerDefinition>> = {
+	opencode2: {
+		command: ["opencode2"],
+		autoCommand: ["opencode2", "--prompt", "{prompt}"],
+		resumeCommand: ["opencode2", "--continue"],
+		autoResumeCommand: ["opencode2", "--continue", "--prompt", "{prompt}"],
+	},
 	opencode: {
 		command: ["opencode"],
 		autoCommand: ["opencode", "--prompt", "{prompt}"],