@agentos-software/opencode 0.0.0-nathan-binding-workspace.abc7ec9

package/scripts/build-opencode-acp.mjs

@@ -0,0 +1,3681 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import {
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const SOURCE_REPOSITORY = "anomalyco/opencode";
+const SOURCE_VERSION = "1.3.13";
+const SOURCE_TARBALL_URL = `https://github.com/${SOURCE_REPOSITORY}/archive/refs/tags/v${SOURCE_VERSION}.tar.gz`;
+
+// Upstream `packages/app/package.json` pins `ghostty-web: github:anomalyco/ghostty-web#main`,
+// but the bundled bun.lock snapshots the SHA below. Because `main` is a moving ref, a fresh
+// `bun install --frozen-lockfile` resolves to whatever `main` points at *now* and fails the
+// lockfile check. Rewriting the manifest to the lockfile's SHA before install keeps frozen-
+// lockfile guarantees intact (i.e. CI still breaks loudly if either side drifts) without
+// trusting arbitrary new HEADs on the ghostty-web branch.
+const GHOSTTY_WEB_PINNED_SHA = "4af877d";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageDir = resolve(__dirname, "..");
+const distDir = resolve(packageDir, "dist");
+const cacheDir = resolve(packageDir, "node_modules", ".cache", "opencode-build");
+const patchPath = resolve(packageDir, "upstream", `opencode-v${SOURCE_VERSION}.patch`);
+const bundleDir = resolve(distDir, "opencode-acp");
+const manifestPath = resolve(distDir, "opencode-acp.manifest.json");
+const SQL_JS_VERSION = "1.14.1";
+const bunBin = resolve(
+	packageDir,
+	"node_modules",
+	".bin",
+	process.platform === "win32" ? "bun.cmd" : "bun",
+);
+
+function run(command, args, options = {}) {
+	const result = spawnSync(command, args, {
+		stdio: "inherit",
+		...options,
+	});
+	if (result.status !== 0) {
+		throw new Error(
+			`Command failed (${result.status ?? "unknown"}): ${command} ${args.join(" ")}`,
+		);
+	}
+	return result;
+}
+
+function pinGhosttyWebRef(sourceRoot) {
+	const manifestPath = resolve(sourceRoot, "packages", "app", "package.json");
+	const raw = readFileSync(manifestPath, "utf-8");
+	const movingRef = '"ghostty-web": "github:anomalyco/ghostty-web#main"';
+	const pinnedRef = `"ghostty-web": "github:anomalyco/ghostty-web#${GHOSTTY_WEB_PINNED_SHA}"`;
+	if (raw.includes(pinnedRef)) return;
+	if (!raw.includes(movingRef)) {
+		throw new Error(
+			`Expected ghostty-web ref ${movingRef} in ${manifestPath}; upstream layout changed — re-audit GHOSTTY_WEB_PINNED_SHA before updating.`,
+		);
+	}
+	writeFileSync(manifestPath, raw.replace(movingRef, pinnedRef));
+}
+
+const PATCHED_SOURCE_FILES = [
+	"packages/opencode/src/cli/cmd/acp.ts",
+	"packages/opencode/src/config/config.ts",
+	"packages/opencode/src/plugin/index.ts",
+	"packages/opencode/src/server/instance.ts",
+	"packages/opencode/src/server/server.ts",
+];
+
+async function ensureNodeAcpPatch(sourceRoot, tarballPath) {
+	const serverFile = resolve(
+		sourceRoot,
+		"packages",
+		"opencode",
+		"src",
+		"server",
+		"server.ts",
+	);
+	const pluginFile = resolve(
+		sourceRoot,
+		"packages",
+		"opencode",
+		"src",
+		"plugin",
+		"index.ts",
+	);
+	const acpFile = resolve(
+		sourceRoot,
+		"packages",
+		"opencode",
+		"src",
+		"cli",
+		"cmd",
+		"acp.ts",
+	);
+	const serverSource = readFileSync(serverFile, "utf-8");
+	const pluginSource = readFileSync(pluginFile, "utf-8");
+	const acpSource = readFileSync(acpFile, "utf-8");
+	const alreadyPatched =
+		serverSource.includes('from "node:http"') &&
+		!serverSource.includes('from "hono/bun"') &&
+		pluginSource.includes("Bun shell is unavailable in the Node ACP build") &&
+		acpSource.includes("const server = await Server.listen(opts)");
+
+	if (alreadyPatched) {
+		return;
+	}
+
+	const scratchRoot = await mkdtemp(join(tmpdir(), "agentos-opencode-patch-"));
+	try {
+		run("tar", ["-xzf", tarballPath, "--strip-components=1", "-C", scratchRoot]);
+		run("git", ["apply", "--whitespace=nowarn", patchPath], { cwd: scratchRoot });
+		for (const relativePath of PATCHED_SOURCE_FILES) {
+			copyFileSync(
+				resolve(scratchRoot, relativePath),
+				resolve(sourceRoot, relativePath),
+			);
+		}
+	} finally {
+		rmSync(scratchRoot, { recursive: true, force: true });
+	}
+
+	const verifiedServerSource = readFileSync(serverFile, "utf-8");
+	const verifiedPluginSource = readFileSync(pluginFile, "utf-8");
+	const verifiedAcpSource = readFileSync(acpFile, "utf-8");
+	if (
+		!verifiedServerSource.includes('from "node:http"') ||
+		verifiedServerSource.includes('from "hono/bun"') ||
+		!verifiedPluginSource.includes("Bun shell is unavailable in the Node ACP build") ||
+		!verifiedAcpSource.includes("const server = await Server.listen(opts)")
+	) {
+		throw new Error("Failed to stage the Node ACP patches into the prepared OpenCode source tree");
+	}
+}
+
+async function downloadFile(url, destination) {
+	const response = await fetch(url);
+	if (!response.ok) {
+		throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+	}
+
+	const buffer = Buffer.from(await response.arrayBuffer());
+	await writeFile(destination, buffer);
+}
+
+async function readMigrations(sourceRoot) {
+	const migrationRoot = join(sourceRoot, "packages", "opencode", "migration");
+	const entries = (await readdir(migrationRoot, { withFileTypes: true }))
+		.filter((entry) => entry.isDirectory() && /^\d{14}/.test(entry.name))
+		.map((entry) => entry.name)
+		.sort();
+
+	return Promise.all(
+		entries.map(async (name) => {
+			const sql = await readFile(
+				join(migrationRoot, name, "migration.sql"),
+				"utf8",
+			);
+			const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(name);
+			const timestamp = match
+				? Date.UTC(
+						Number(match[1]),
+						Number(match[2]) - 1,
+						Number(match[3]),
+						Number(match[4]),
+						Number(match[5]),
+						Number(match[6]),
+					)
+				: 0;
+			return { name, sql, timestamp };
+		}),
+	);
+}
+
+async function rewriteSourceFile(sourceRoot, relativePath, transform) {
+	const filePath = resolve(sourceRoot, relativePath);
+	const original = await readFile(filePath, "utf8");
+	const next = transform(original);
+	if (next !== original) {
+		await writeFile(filePath, next);
+	}
+}
+
+async function ensureSqlJsDependency(sourceRoot) {
+	const packageJsonPath = resolve(
+		sourceRoot,
+		"packages",
+		"opencode",
+		"package.json",
+	);
+	const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+	const dependencies = packageJson.dependencies ?? {};
+	const bunStoreDir = resolve(sourceRoot, "node_modules", ".bun");
+	const hasInstalledSqlJs =
+		existsSync(bunStoreDir) &&
+		(await readdir(bunStoreDir)).some((entry) => entry.startsWith("sql.js@"));
+	if (dependencies["sql.js"] === SQL_JS_VERSION && hasInstalledSqlJs) {
+		return;
+	}
+
+	packageJson.dependencies = {
+		...dependencies,
+		"sql.js": SQL_JS_VERSION,
+	};
+	await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+	run(bunBin, ["install"], { cwd: sourceRoot });
+}
+
+async function applyNodeAcpRuntimeTweaks(sourceRoot) {
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/cli/cmd/acp.ts"),
+		`import type { Argv, InferredOptionTypes } from "yargs"
+import { cmd } from "./cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { Log } from "../../util/log"
+
+const options = {
+  port: {
+    type: "number" as const,
+    describe: "port to listen on",
+    default: 0,
+  },
+  hostname: {
+    type: "string" as const,
+    describe: "hostname to listen on",
+    default: "127.0.0.1",
+  },
+  mdns: {
+    type: "boolean" as const,
+    describe: "enable mDNS service discovery (defaults hostname to 0.0.0.0)",
+    default: false,
+  },
+  "mdns-domain": {
+    type: "string" as const,
+    describe: "custom domain name for mDNS service (default: opencode.local)",
+    default: "opencode.local",
+  },
+  cors: {
+    type: "string" as const,
+    array: true,
+    describe: "additional domains to allow for CORS",
+    default: [] as string[],
+  },
+}
+
+type NetworkOptions = InferredOptionTypes<typeof options>
+
+function withNetworkOptions<T>(yargs: Argv<T>) {
+  return yargs.options(options)
+}
+
+async function resolveNetworkOptions(args: NetworkOptions) {
+  const { Config } = await import("../../config/config")
+  const config = await Config.getGlobal()
+  const portExplicitlySet = process.argv.includes("--port")
+  const hostnameExplicitlySet = process.argv.includes("--hostname")
+  const mdnsExplicitlySet = process.argv.includes("--mdns")
+  const mdnsDomainExplicitlySet = process.argv.includes("--mdns-domain")
+  const corsExplicitlySet = process.argv.includes("--cors")
+
+  const mdns = mdnsExplicitlySet ? args.mdns : (config?.server?.mdns ?? args.mdns)
+  const mdnsDomain = mdnsDomainExplicitlySet ? args["mdns-domain"] : (config?.server?.mdnsDomain ?? args["mdns-domain"])
+  const port = portExplicitlySet ? args.port : (config?.server?.port ?? args.port)
+  const hostname = hostnameExplicitlySet
+    ? args.hostname
+    : mdns && !config?.server?.hostname
+      ? "0.0.0.0"
+      : (config?.server?.hostname ?? args.hostname)
+  const configCors = config?.server?.cors ?? []
+  const argsCors = Array.isArray(args.cors) ? args.cors : args.cors ? [args.cors] : []
+  const cors = [...configCors, ...argsCors]
+
+  return { hostname, port, mdns, mdnsDomain, cors }
+}
+
+function wrapData<T>(data: T) {
+  return { data }
+}
+
+async function loadProviderCatalog(directory: string | undefined) {
+  const [{ Config }] = await Promise.all([import("../../config/config")])
+
+  return withDirectory(directory, async () => {
+    const config = await Config.get()
+    const providers: any[] = []
+
+    if (config?.provider?.anthropic || config?.model?.startsWith("anthropic/") || process.env.ANTHROPIC_API_KEY) {
+      providers.push({
+        id: "anthropic",
+        name: "Anthropic",
+        source: "config",
+        env: ["ANTHROPIC_API_KEY"],
+        options: {
+          ...(config?.provider?.anthropic?.options ?? {}),
+        },
+        models: {
+          "claude-sonnet-4-20250514": {
+            id: "claude-sonnet-4-20250514",
+            providerID: "anthropic",
+            api: { id: "claude-sonnet-4-20250514", url: "", npm: "@ai-sdk/anthropic" },
+            name: "Claude Sonnet 4",
+            family: "claude-sonnet-4",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-05-14",
+            variants: {},
+          },
+          "claude-opus-4-1-20250805": {
+            id: "claude-opus-4-1-20250805",
+            providerID: "anthropic",
+            api: { id: "claude-opus-4-1-20250805", url: "", npm: "@ai-sdk/anthropic" },
+            name: "Claude Opus 4.1",
+            family: "claude-opus-4-1",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-08-05",
+            variants: {},
+          },
+          "claude-haiku-4-5-20251001": {
+            id: "claude-haiku-4-5-20251001",
+            providerID: "anthropic",
+            api: { id: "claude-haiku-4-5-20251001", url: "", npm: "@ai-sdk/anthropic" },
+            name: "Claude Haiku 4.5",
+            family: "claude-haiku-4-5",
+            capabilities: {
+              temperature: true,
+              reasoning: false,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 16000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-10-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (config?.provider?.openai || config?.model?.startsWith("openai/") || process.env.OPENAI_API_KEY) {
+      providers.push({
+        id: "openai",
+        name: "OpenAI",
+        source: "config",
+        env: ["OPENAI_API_KEY"],
+        options: {
+          ...(config?.provider?.openai?.options ?? {}),
+        },
+        models: {
+          "gpt-5": {
+            id: "gpt-5",
+            providerID: "openai",
+            api: { id: "gpt-5", url: "", npm: "@ai-sdk/openai" },
+            name: "GPT-5",
+            family: "gpt-5",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+          "gpt-5-mini": {
+            id: "gpt-5-mini",
+            providerID: "openai",
+            api: { id: "gpt-5-mini", url: "", npm: "@ai-sdk/openai" },
+            name: "GPT-5 Mini",
+            family: "gpt-5-mini",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 16000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (
+      config?.provider?.google ||
+      config?.model?.startsWith("google/") ||
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    ) {
+      providers.push({
+        id: "google",
+        name: "Google",
+        source: "config",
+        env: ["GOOGLE_GENERATIVE_AI_API_KEY"],
+        options: {
+          ...(config?.provider?.google?.options ?? {}),
+        },
+        models: {
+          "gemini-2.5-pro": {
+            id: "gemini-2.5-pro",
+            providerID: "google",
+            api: { id: "gemini-2.5-pro", url: "", npm: "@ai-sdk/google" },
+            name: "Gemini 2.5 Pro",
+            family: "gemini-2.5-pro",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+          "gemini-2.5-flash": {
+            id: "gemini-2.5-flash",
+            providerID: "google",
+            api: { id: "gemini-2.5-flash", url: "", npm: "@ai-sdk/google" },
+            name: "Gemini 2.5 Flash",
+            family: "gemini-2.5-flash",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 16000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (
+      config?.provider?.["google-vertex"] ||
+      config?.model?.startsWith("google-vertex/") ||
+      (process.env.GOOGLE_VERTEX_PROJECT && process.env.GOOGLE_VERTEX_LOCATION)
+    ) {
+      providers.push({
+        id: "google-vertex",
+        name: "Google Vertex",
+        source: "config",
+        env: [],
+        options: {
+          ...(config?.provider?.["google-vertex"]?.options ?? {}),
+        },
+        models: {
+          "gemini-2.5-pro": {
+            id: "gemini-2.5-pro",
+            providerID: "google-vertex",
+            api: { id: "gemini-2.5-pro", url: "", npm: "@ai-sdk/google-vertex" },
+            name: "Gemini 2.5 Pro",
+            family: "gemini-2.5-pro",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (config?.provider?.groq || config?.model?.startsWith("groq/") || process.env.GROQ_API_KEY) {
+      providers.push({
+        id: "groq",
+        name: "Groq",
+        source: "config",
+        env: ["GROQ_API_KEY"],
+        options: {
+          ...(config?.provider?.groq?.options ?? {}),
+        },
+        models: {
+          "llama-3.3-70b-versatile": {
+            id: "llama-3.3-70b-versatile",
+            providerID: "groq",
+            api: { id: "llama-3.3-70b-versatile", url: "", npm: "@ai-sdk/groq" },
+            name: "Llama 3.3 70B Versatile",
+            family: "llama-3.3-70b",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: false,
+              toolcall: true,
+              input: { text: true, audio: false, image: false, video: false, pdf: false },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (config?.provider?.mistral || config?.model?.startsWith("mistral/") || process.env.MISTRAL_API_KEY) {
+      providers.push({
+        id: "mistral",
+        name: "Mistral",
+        source: "config",
+        env: ["MISTRAL_API_KEY"],
+        options: {
+          ...(config?.provider?.mistral?.options ?? {}),
+        },
+        models: {
+          "mistral-small-latest": {
+            id: "mistral-small-latest",
+            providerID: "mistral",
+            api: { id: "mistral-small-latest", url: "", npm: "@ai-sdk/mistral" },
+            name: "Mistral Small Latest",
+            family: "mistral-small",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-01-01",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    if (providers.length === 0) {
+      providers.push({
+        id: "anthropic",
+        name: "Anthropic",
+        source: "custom",
+        env: ["ANTHROPIC_API_KEY"],
+        options: {},
+        models: {
+          "claude-sonnet-4-20250514": {
+            id: "claude-sonnet-4-20250514",
+            providerID: "anthropic",
+            api: { id: "claude-sonnet-4-20250514", url: "", npm: "@ai-sdk/anthropic" },
+            name: "Claude Sonnet 4",
+            family: "claude-sonnet-4",
+            capabilities: {
+              temperature: true,
+              reasoning: true,
+              attachment: true,
+              toolcall: true,
+              input: { text: true, audio: false, image: true, video: false, pdf: true },
+              output: { text: true, audio: false, image: false, video: false, pdf: false },
+              interleaved: false,
+            },
+            cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+            limit: { context: 200000, output: 32000 },
+            status: "active",
+            options: {},
+            headers: {},
+            release_date: "2025-05-14",
+            variants: {},
+          },
+        },
+      })
+    }
+
+    const defaults = Object.fromEntries(
+      providers.map((provider) => {
+        const specifiedModel =
+          typeof config.model === "string" && config.model.startsWith(provider.id + "/")
+            ? config.model.slice(provider.id.length + 1)
+            : undefined
+        return [
+          provider.id,
+          specifiedModel ?? Object.keys(provider.models)[0] ?? "",
+        ]
+      }),
+    )
+
+    return { providers, default: defaults }
+  })
+}
+
+async function runServiceWithCurrentInstance<T>(
+  serviceModule: { Service: any; defaultLayer: any },
+  ctx: any,
+  fn: (service: any) => any,
+): Promise<T> {
+  const [{ Effect, ManagedRuntime }, { InstanceRef }, { memoMap }, { Instance }] = await Promise.all([
+    import("effect"),
+    import("../../effect/instance-ref"),
+    import("../../effect/run-service"),
+    import("../../project/instance"),
+  ])
+  console.error("[opencode-acp] serviceRuntime:ctx", ctx.directory)
+  ;(globalThis as typeof globalThis & { __agentosOpencodeInstanceFallback?: unknown }).__agentosOpencodeInstanceFallback =
+    ctx
+  const runtime = ManagedRuntime.make(serviceModule.defaultLayer, { memoMap })
+  try {
+    const result = await Instance.restore(
+      ctx,
+      () =>
+        runtime.runPromise(
+          Effect.provideService(serviceModule.Service.use(fn), InstanceRef, ctx),
+        ),
+    )
+    console.error("[opencode-acp] serviceRuntime:done", ctx.directory)
+    return result
+  } catch (error) {
+    console.error(
+      "[opencode-acp] serviceRuntime:error",
+      error instanceof Error ? error.stack ?? error.message : String(error),
+    )
+    throw error
+  }
+}
+
+async function loadAgentCatalog(directory: string | undefined) {
+  const { Config } = await import("../../config/config")
+
+  return withDirectory(directory, async () => {
+    const cfg = await Config.get()
+    const agents = new Map<string, any>([
+      [
+        "build",
+        {
+          name: "build",
+          description: "The default agent. Executes tools based on configured permissions.",
+          mode: "primary",
+        },
+      ],
+      [
+        "plan",
+        {
+          name: "plan",
+          description: "Plan mode. Disallows all edit tools.",
+          mode: "primary",
+        },
+      ],
+      [
+        "general",
+        {
+          name: "general",
+          description:
+            "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.",
+          mode: "subagent",
+        },
+      ],
+      [
+        "explore",
+        {
+          name: "explore",
+          description:
+            "Fast agent specialized for exploring codebases. Use this when you need to quickly find files, search code, or answer questions about the codebase.",
+          mode: "subagent",
+        },
+      ],
+      ["compaction", { name: "compaction", mode: "primary", hidden: true }],
+      ["title", { name: "title", mode: "primary", hidden: true }],
+      ["summary", { name: "summary", mode: "primary", hidden: true }],
+    ])
+
+    for (const [key, value] of Object.entries(cfg.agent ?? {})) {
+      if (value?.disable) {
+        agents.delete(key)
+        continue
+      }
+      const current = agents.get(key) ?? {
+        name: key,
+        mode: "all",
+      }
+      agents.set(key, {
+        ...current,
+        ...(value?.name ? { name: value.name } : {}),
+        ...(value?.description ? { description: value.description } : {}),
+        ...(value?.mode ? { mode: value.mode } : {}),
+        ...(value?.hidden !== undefined ? { hidden: value.hidden } : {}),
+      })
+    }
+
+    const defaultAgent = cfg.default_agent ?? "build"
+    return Array.from(agents.values()).sort((a, b) => {
+      const aRank = a.name === defaultAgent ? 0 : 1
+      const bRank = b.name === defaultAgent ? 0 : 1
+      if (aRank !== bRank) return aRank - bRank
+      return a.name.localeCompare(b.name)
+    })
+  })
+}
+
+async function loadCommandCatalog(directory: string | undefined) {
+  const { Config } = await import("../../config/config")
+
+  return withDirectory(directory, async () => {
+    const cfg = await Config.get()
+    const commands = new Map<string, any>([
+      ["init", { name: "init", description: "create/update AGENTS.md" }],
+      ["review", { name: "review", description: "review changes [commit|branch|pr], defaults to uncommitted" }],
+    ])
+
+    for (const [name, command] of Object.entries(cfg.command ?? {})) {
+      commands.set(name, {
+        name,
+        ...(command?.description ? { description: command.description } : {}),
+      })
+    }
+
+    return Array.from(commands.values()).sort((a, b) => a.name.localeCompare(b.name))
+  })
+}
+
+async function withDirectory<T>(
+  directory: string | undefined,
+  fn: (ctx: any) => Promise<T>,
+): Promise<T> {
+  console.error("[opencode-acp] withDirectory:start", directory ?? process.cwd())
+  const [{ Instance }, { InstanceBootstrap }] = await Promise.all([
+    import("../../project/instance"),
+    import("../../project/bootstrap"),
+  ])
+  console.error("[opencode-acp] withDirectory:modules:done", directory ?? process.cwd())
+  return Instance.provide({
+    directory: directory ?? process.cwd(),
+    init: InstanceBootstrap,
+    fn: () => {
+      const ctx = Instance.current
+      ;(globalThis as typeof globalThis & { __agentosOpencodeInstanceFallback?: unknown }).__agentosOpencodeInstanceFallback =
+        ctx
+      return fn(ctx)
+    },
+  })
+}
+
+async function ensureProjectors() {
+  if ((globalThis as any).__agentosOpencodeProjectorsReady) return
+  console.error("[opencode-acp] projectors:ensure:start")
+  const [{ SyncEvent }, { default: sessionProjectors }] = await Promise.all([
+    import("../../sync"),
+    import("../../session/projectors"),
+  ])
+  SyncEvent.init({
+    projectors: sessionProjectors,
+  })
+  ;(globalThis as any).__agentosOpencodeProjectorsReady = true
+  console.error("[opencode-acp] projectors:ensure:done")
+}
+
+async function createGlobalEventStream(signal?: AbortSignal) {
+  const { GlobalBus } = await import("../../bus/global")
+  let closed = false
+  const queue: any[] = []
+  let nextResolve: ((result: IteratorResult<any>) => void) | undefined
+
+  const close = () => {
+    if (closed) return
+    closed = true
+    GlobalBus.off("event", onEvent)
+    signal?.removeEventListener("abort", close)
+    nextResolve?.({ done: true, value: undefined })
+    nextResolve = undefined
+  }
+
+  const onEvent = (event: any) => {
+    if (closed) return
+    if (nextResolve) {
+      const resolve = nextResolve
+      nextResolve = undefined
+      resolve({ done: false, value: event })
+      return
+    }
+    queue.push(event)
+  }
+
+  GlobalBus.on("event", onEvent)
+  if (signal) {
+    if (signal.aborted) close()
+    else signal.addEventListener("abort", close, { once: true })
+  }
+
+  return {
+    stream: (async function* () {
+      try {
+        while (true) {
+          if (queue.length > 0) {
+            yield queue.shift()
+            continue
+          }
+
+          const next = await new Promise<IteratorResult<any>>((resolve) => {
+            nextResolve = resolve
+          })
+          if (next.done) return
+          yield next.value
+        }
+      } finally {
+        close()
+      }
+    })(),
+  }
+}
+
+function createLocalSdk() {
+  return {
+    global: {
+      event: async ({ signal }: { signal?: AbortSignal }) => createGlobalEventStream(signal),
+    },
+    permission: {
+      reply: async ({ requestID, reply, directory }: any) =>
+        wrapData(
+          await withDirectory(directory, async () => {
+            const { Permission } = await import("../../permission")
+            await Permission.reply({ requestID, reply })
+            return true
+          }),
+        ),
+    },
+    config: {
+      get: async ({ directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { Config } = await import("../../config/config")
+            return withDirectory(directory, async () => {
+              console.error("[opencode-acp] sdk.config.get:start", directory ?? process.cwd())
+              const result = await Config.get()
+              console.error("[opencode-acp] sdk.config.get:done", directory ?? process.cwd())
+              return result
+            })
+          })(),
+        ),
+      providers: async ({ directory }: any) =>
+        wrapData(
+          await (async () => {
+            console.error("[opencode-acp] sdk.config.providers:start", directory ?? process.cwd())
+            return withDirectory(directory, async () => {
+              const result = await loadProviderCatalog(directory)
+              console.error(
+                "[opencode-acp] sdk.config.providers:done",
+                directory ?? process.cwd(),
+                result.providers.length,
+              )
+              return result
+            })
+          })(),
+        ),
+    },
+    app: {
+      agents: async ({ directory }: any) =>
+        wrapData(
+          await loadAgentCatalog(directory),
+        ),
+    },
+    command: {
+      list: async ({ directory }: any) =>
+        wrapData(
+          await loadCommandCatalog(directory),
+        ),
+    },
+    mcp: {
+      add: async ({ directory, name, config }: any) =>
+        wrapData(
+          await (async () => {
+            const { MCP } = await import("../../mcp")
+            return withDirectory(directory, async () => MCP.add(name, config))
+          })(),
+        ),
+    },
+    session: {
+      create: async ({ directory, title, permission, workspaceID, parentID }: any) =>
+        wrapData(
+          await (async () => {
+            await ensureProjectors()
+            return withDirectory(directory, async (ctx) => {
+              const { Session } = await import("../../session")
+              console.error("[opencode-acp] sdk.session.create:start", directory ?? process.cwd())
+              try {
+                const result = await runServiceWithCurrentInstance(Session, ctx, (service) =>
+                  service.create({
+                    ...(title ? { title } : {}),
+                    ...(permission ? { permission } : {}),
+                    ...(workspaceID ? { workspaceID } : {}),
+                    ...(parentID ? { parentID } : {}),
+                  }),
+                )
+                console.error("[opencode-acp] sdk.session.create:done", directory ?? process.cwd())
+                return result
+              } catch (error) {
+                console.error(
+                  "[opencode-acp] sdk.session.create:error",
+                  error instanceof Error ? error.stack ?? error.message : String(error),
+                )
+                throw error
+              }
+            })
+          })(),
+        ),
+      get: async ({ sessionID, directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { Session } = await import("../../session")
+            return withDirectory(directory, async (ctx) =>
+              runServiceWithCurrentInstance(Session, ctx, (service) => service.get(sessionID)),
+            )
+          })(),
+        ),
+      list: async ({ directory, roots, start, search, limit }: any) =>
+        wrapData(
+          await (async () => {
+            const { Session } = await import("../../session")
+            return withDirectory(directory, async (ctx) => {
+              return runServiceWithCurrentInstance(Session, ctx, (service) =>
+                service.list({ directory, roots, start, search, limit }),
+              )
+            })
+          })(),
+        ),
+      fork: async ({ sessionID, messageID, directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { Session } = await import("../../session")
+            await ensureProjectors()
+            return withDirectory(directory, async (ctx) =>
+              runServiceWithCurrentInstance(Session, ctx, (service) =>
+                service.fork({
+                  sessionID,
+                  ...(messageID ? { messageID } : {}),
+                }),
+              ),
+            )
+          })(),
+        ),
+      messages: async ({ sessionID, limit, directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { Session } = await import("../../session")
+            return withDirectory(directory, async (ctx) =>
+              runServiceWithCurrentInstance(Session, ctx, (service) =>
+                service.messages({ sessionID, ...(limit ? { limit } : {}) }),
+              ),
+            )
+          })(),
+        ),
+      message: async ({ sessionID, messageID, directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { MessageV2 } = await import("../../session/message-v2")
+            return withDirectory(directory, async () => MessageV2.get({ sessionID, messageID }))
+          })(),
+        ),
+      prompt: async ({ sessionID, directory, ...input }: any) =>
+        wrapData(
+          await (async () => {
+            const { SessionPrompt } = await import("../../session/prompt")
+            await ensureProjectors()
+            return withDirectory(directory, async (ctx) =>
+              runServiceWithCurrentInstance(SessionPrompt, ctx, (service) =>
+                service.prompt({ sessionID, ...input }),
+              ),
+            )
+          })(),
+        ),
+      command: async ({ sessionID, directory, ...input }: any) =>
+        wrapData(
+          await (async () => {
+            const { SessionPrompt } = await import("../../session/prompt")
+            await ensureProjectors()
+            return withDirectory(directory, async (ctx) =>
+              runServiceWithCurrentInstance(SessionPrompt, ctx, (service) =>
+                service.command({ sessionID, ...input }),
+              ),
+            )
+          })(),
+        ),
+      summarize: async ({ sessionID, directory, providerID, modelID, auto = false }: any) =>
+        wrapData(
+          await (async () => {
+            const [{ Session }, { SessionRevert }, { SessionCompaction }, { SessionPrompt }, { Agent }] =
+              await Promise.all([
+                import("../../session"),
+                import("../../session/revert"),
+                import("../../session/compaction"),
+                import("../../session/prompt"),
+                import("../../agent/agent"),
+              ])
+            await ensureProjectors()
+            return withDirectory(directory, async (ctx) => {
+              const session = await Session.get(sessionID)
+              await SessionRevert.cleanup(session)
+              const messages = await Session.messages({ sessionID })
+              let currentAgent = await Agent.defaultAgent()
+              for (let i = messages.length - 1; i >= 0; i--) {
+                const info = messages[i].info
+                if (info.role === "user") {
+                  currentAgent = info.agent || (await Agent.defaultAgent())
+                  break
+                }
+              }
+              await SessionCompaction.create({
+                sessionID,
+                agent: currentAgent,
+                model: { providerID, modelID },
+                auto,
+              })
+              await runServiceWithCurrentInstance(SessionPrompt, ctx, (service) =>
+                service.loop({ sessionID }),
+              )
+              return true
+            })
+          })(),
+        ),
+      abort: async ({ sessionID, directory }: any) =>
+        wrapData(
+          await (async () => {
+            const { SessionPrompt } = await import("../../session/prompt")
+            return withDirectory(directory, async (ctx) => {
+              await runServiceWithCurrentInstance(SessionPrompt, ctx, (service) =>
+                service.cancel(sessionID),
+              )
+              return true
+            })
+          })(),
+        ),
+    },
+  } as any
+}
+
+export const AcpCommand = cmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server",
+  builder: (yargs) => {
+    return withNetworkOptions(yargs).option("cwd", {
+      describe: "working directory",
+      type: "string",
+      default: process.cwd(),
+    })
+  },
+  handler: async (args: NetworkOptions) => {
+    process.env.OPENCODE_CLIENT = "acp"
+    process.env.OPENCODE_DISABLE_MODELS_FETCH = process.env.OPENCODE_DISABLE_MODELS_FETCH ?? "1"
+    process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS ?? "1"
+    const [{ ACP }] = await Promise.all([import("../../acp/agent")])
+
+    const log = Log.create({ service: "acp-command" })
+    console.error("[opencode-acp] bootstrap:entered")
+    console.error("[opencode-acp] network:resolve:start")
+    const opts = await resolveNetworkOptions(args)
+    console.error("[opencode-acp] network:resolve:done", JSON.stringify(opts))
+
+    console.error("[opencode-acp] sdk:create:start")
+    const sdk = createLocalSdk()
+    console.error("[opencode-acp] sdk:create:done")
+
+    console.error("[opencode-acp] streams:create:start")
+    const input = new WritableStream<Uint8Array>({
+      write(chunk) {
+        return new Promise<void>((resolve, reject) => {
+          process.stdout.write(chunk, (err) => {
+            if (err) {
+              reject(err)
+            } else {
+              resolve()
+            }
+          })
+        })
+      },
+    })
+    const output = new ReadableStream<Uint8Array>({
+      start(controller) {
+        process.stdin.on("data", (chunk: Buffer) => {
+          controller.enqueue(new Uint8Array(chunk))
+        })
+        process.stdin.on("end", () => controller.close())
+        process.stdin.on("error", (err) => controller.error(err))
+      },
+    })
+    console.error("[opencode-acp] streams:create:done")
+
+    console.error("[opencode-acp] ndjson:start")
+    const stream = ndJsonStream(input, output)
+    console.error("[opencode-acp] ndjson:done")
+    console.error("[opencode-acp] agent:init:start")
+    const agent = await ACP.init({ sdk })
+    console.error("[opencode-acp] agent:init:done")
+
+    console.error("[opencode-acp] connection:start")
+    new AgentSideConnection((conn) => {
+      return agent.create(conn, { sdk })
+    }, stream)
+    console.error("[opencode-acp] connection:done")
+
+    log.info("setup connection")
+    process.stdin.resume()
+    await new Promise((resolve, reject) => {
+      process.stdin.on("end", resolve)
+      process.stdin.on("error", reject)
+    })
+  },
+})
+`,
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/server/instance.ts",
+		(contents) =>
+			contents
+				.replace('import { TuiRoutes } from "./routes/tui"\n', "")
+				.replace('import { PtyRoutes } from "./routes/pty"\n', "")
+				.replace('    .route("/pty", PtyRoutes())\n', "")
+				.replace('    .route("/tui", TuiRoutes())\n', ""),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/agent/agent.ts",
+		(contents) =>
+			contents.replace(
+				`                    [path.relative(Instance.worktree, path.join(Global.Path.data, path.join("plans", "*.md")))]:
+                      "allow",`,
+				`                    [path.relative(ctx.worktree, path.join(Global.Path.data, path.join("plans", "*.md")))]:
+                      "allow",`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/shell/shell.ts",
+		(contents) => contents.replaceAll("Bun.which(", "which("),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/server/server.ts",
+		(contents) =>
+			contents
+				.replace('import { MDNS } from "./mdns"\n', "")
+				.replace(
+					`    if (shouldPublishMDNS) {
+      MDNS.publish(server.port, opts.mdnsDomain)
+    } else if (opts.mdns) {`,
+					`    let mdns:
+      | {
+          publish(port: number, domain?: string): void
+          unpublish(): void
+        }
+      | undefined
+    if (shouldPublishMDNS) {
+      ;({ MDNS: mdns } = await import("./mdns"))
+      mdns.publish(server.port, opts.mdnsDomain)
+    } else if (opts.mdns) {`,
+				)
+				.replace(
+					"      if (shouldPublishMDNS) MDNS.unpublish()\n",
+					"      if (shouldPublishMDNS) mdns?.unpublish()\n",
+				),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/project/bootstrap.ts",
+		(contents) =>
+			contents.replace(
+				`  Bus.subscribe(Command.Event.Executed, async (payload) => {
+    if (payload.properties.name === Command.Default.INIT) {
+      Project.setInitialized(Instance.project.id)
+    }
+  })
+`,
+				`  Log.Default.info("bootstrap step", { step: "bus.subscribe:skipped" })
+`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/acp/agent.ts",
+		(contents) =>
+			contents
+				.replaceAll(
+					`      console.error("[opencode-acp] agent.loadSessionMode:commands:done", directory, commands.length)
+`,
+					"",
+				)
+				.replace(
+					`          const defaultAgentName = await AgentModule.defaultAgent()
+          const resolvedModeId =
+            availableModes.find((mode) => mode.name === defaultAgentName)?.id ?? availableModes[0].id
+`,
+					`          const resolvedModeId = availableModes[0].id
+`,
+				)
+				.replace(
+					`        const model = await defaultModel(this.config, directory)
+`,
+					`        console.error("[opencode-acp] agent.newSession:defaultModel:start", directory)
+        const model = await defaultModel(this.config, directory)
+        console.error("[opencode-acp] agent.newSession:defaultModel:done", directory, model.providerID, model.modelID)
+`,
+				)
+				.replace(
+					`        const state = await this.sessionManager.create(params.cwd, params.mcpServers, model)
+`,
+					`        console.error("[opencode-acp] agent.newSession:sessionManager.create:start", directory)
+        const state = await this.sessionManager.create(params.cwd, params.mcpServers, model)
+        console.error("[opencode-acp] agent.newSession:sessionManager.create:done", directory, state.id)
+`,
+				)
+				.replace(
+					`        const load = await this.loadSessionMode({
+`,
+					`        console.error("[opencode-acp] agent.newSession:loadSessionMode:start", directory)
+        const load = await this.loadSessionMode({
+`,
+				)
+				.replace(
+					`      const providers = await this.sdk.config.providers({ directory }).then((x) => x.data!.providers)
+`,
+					`      console.error("[opencode-acp] agent.loadSessionMode:providers:start", directory)
+      const providers = await this.sdk.config.providers({ directory }).then((x) => x.data!.providers)
+      console.error("[opencode-acp] agent.loadSessionMode:providers:done", directory, providers.length)
+`,
+				)
+				.replace(
+					`      const modeState = await this.resolveModeState(directory, sessionId)
+`,
+					`      console.error("[opencode-acp] agent.loadSessionMode:resolveModeState:start", directory)
+      const modeState = await this.resolveModeState(directory, sessionId)
+      console.error("[opencode-acp] agent.loadSessionMode:resolveModeState:done", directory, modeState.availableModes.length)
+`,
+				)
+				.replace(
+					`      const commands = await this.config.sdk.command
+`,
+					`      console.error("[opencode-acp] agent.loadSessionMode:commands:start", directory)
+      const commands = await this.config.sdk.command
+`,
+				),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/project/bootstrap.ts",
+		(contents) =>
+			contents.replace(
+				`  Log.Default.info("bootstrap step", { step: "snapshot.init:start" })
+  Snapshot.init()
+  Log.Default.info("bootstrap step", { step: "snapshot.init:done" })
+`,
+				`  Log.Default.info("bootstrap step", { step: "snapshot.init:skipped" })
+`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/util/filesystem.ts",
+		(contents) => {
+			if (contents.includes("cachedAgentOsGuestPathMappings")) {
+				return contents;
+			}
+
+			return contents
+				.replace(
+					'import { dirname, join, relative, resolve as pathResolve, win32 } from "path"\n',
+					`import { dirname, join, relative, resolve as pathResolve, win32 } from "path"
+
+type AgentOsGuestPathMapping = {
+  guestPath?: string
+  hostPath?: string
+}
+
+let cachedAgentOsGuestPathMappings:
+  | Array<{ guestPath: string; hostPath: string }>
+  | undefined
+
+function runtimeWindowsPath(p: string): string {
+  if (process.platform !== "win32") return p
+  return p
+    .replace(/^\\/([a-zA-Z]):(?:[\\\\/]|$)/, (_, drive) => \`\${drive.toUpperCase()}:/\`)
+    .replace(/^\\/([a-zA-Z])(?:\\/|$)/, (_, drive) => \`\${drive.toUpperCase()}:/\`)
+    .replace(/^\\/cygdrive\\/([a-zA-Z])(?:\\/|$)/, (_, drive) => \`\${drive.toUpperCase()}:/\`)
+    .replace(/^\\/mnt\\/([a-zA-Z])(?:\\/|$)/, (_, drive) => \`\${drive.toUpperCase()}:/\`)
+}
+
+function agentOsGuestPathMappings() {
+  if (cachedAgentOsGuestPathMappings) return cachedAgentOsGuestPathMappings
+  const raw = process.env.AGENT_OS_GUEST_PATH_MAPPINGS
+  if (!raw) {
+    cachedAgentOsGuestPathMappings = []
+    return cachedAgentOsGuestPathMappings
+  }
+
+  try {
+    const parsed = JSON.parse(raw)
+    if (!Array.isArray(parsed)) {
+      cachedAgentOsGuestPathMappings = []
+      return cachedAgentOsGuestPathMappings
+    }
+
+    cachedAgentOsGuestPathMappings = parsed
+      .filter(
+        (item): item is AgentOsGuestPathMapping =>
+          typeof item === "object" &&
+          item !== null &&
+          typeof item.guestPath === "string" &&
+          typeof item.hostPath === "string",
+      )
+      .map((item) => ({
+        guestPath: item.guestPath === "/" ? "/" : pathResolve(runtimeWindowsPath(item.guestPath)),
+        hostPath: pathResolve(runtimeWindowsPath(item.hostPath)),
+      }))
+      .sort((left, right) => right.guestPath.length - left.guestPath.length)
+    return cachedAgentOsGuestPathMappings
+  } catch {
+    cachedAgentOsGuestPathMappings = []
+    return cachedAgentOsGuestPathMappings
+  }
+}
+
+function runtimePath(p: string): string {
+  if (!p.startsWith("/")) return p
+
+  const normalized = pathResolve(runtimeWindowsPath(p))
+  for (const mapping of agentOsGuestPathMappings()) {
+    if (
+      mapping.guestPath !== "/" &&
+      normalized !== mapping.guestPath &&
+      !normalized.startsWith(\`\${mapping.guestPath}/\`)
+    ) {
+      continue
+    }
+
+    const suffix =
+      mapping.guestPath === "/"
+        ? normalized.slice(1)
+        : normalized.slice(mapping.guestPath.length).replace(/^[/\\\\]+/, "")
+    return suffix ? join(mapping.hostPath, suffix) : mapping.hostPath
+  }
+
+  return p
+}
+`,
+				)
+				.replace(
+					`    return existsSync(p)
+`,
+					`    return existsSync(runtimePath(p))
+`,
+				)
+				.replace(
+					`      return statSync(p).isDirectory()
+`,
+					`      return statSync(runtimePath(p)).isDirectory()
+`,
+				)
+				.replace(
+					`    return statSync(p, { throwIfNoEntry: false }) ?? undefined
+`,
+					`    return statSync(runtimePath(p), { throwIfNoEntry: false }) ?? undefined
+`,
+				)
+				.replace(
+					`    return statFile(p).catch((e) => {
+`,
+					`    return statFile(runtimePath(p)).catch((e) => {
+`,
+				)
+				.replace(
+					`    return readFile(p, "utf-8")
+`,
+					`    return readFile(runtimePath(p), "utf-8")
+`,
+				)
+				.replace(
+					`    return JSON.parse(await readFile(p, "utf-8"))
+`,
+					`    return JSON.parse(await readFile(runtimePath(p), "utf-8"))
+`,
+				)
+				.replace(
+					`    return readFile(p)
+`,
+					`    return readFile(runtimePath(p))
+`,
+				)
+				.replace(
+					`    const buf = await readFile(p)
+`,
+					`    const buf = await readFile(runtimePath(p))
+`,
+				)
+				.replace(
+					`    try {
+      if (mode) {
+        await writeFile(p, content, { mode })
+      } else {
+        await writeFile(p, content)
+      }
+    } catch (e) {
+      if (isEnoent(e)) {
+        await mkdir(dirname(p), { recursive: true })
+        if (mode) {
+          await writeFile(p, content, { mode })
+        } else {
+          await writeFile(p, content)
+        }
+        return
+      }
+      throw e
+    }
+`,
+					`    const target = runtimePath(p)
+    try {
+      if (mode) {
+        await writeFile(target, content, { mode })
+      } else {
+        await writeFile(target, content)
+      }
+    } catch (e) {
+      if (isEnoent(e)) {
+        await mkdir(dirname(target), { recursive: true })
+        if (mode) {
+          await writeFile(target, content, { mode })
+        } else {
+          await writeFile(target, content)
+        }
+        return
+      }
+      throw e
+    }
+`,
+				)
+				.replace(
+					`    const dir = dirname(p)
+`,
+					`    const target = runtimePath(p)
+    const dir = dirname(target)
+`,
+				)
+				.replace(
+					`    const writeStream = createWriteStream(p)
+`,
+					`    const writeStream = createWriteStream(target)
+`,
+				)
+				.replace(
+					`      await chmod(p, mode)
+`,
+					`      await chmod(target, mode)
+`,
+				);
+		},
+	);
+
+	for (const relativePath of [
+		"packages/opencode/src/cli/cmd/mcp.ts",
+		"packages/opencode/src/config/config.ts",
+		"packages/opencode/src/config/migrate-tui-config.ts",
+		"packages/opencode/src/config/paths.ts",
+		"packages/opencode/src/plugin/install.ts",
+	]) {
+		await rewriteSourceFile(sourceRoot, relativePath, (contents) =>
+			contents.replaceAll(
+				'"jsonc-parser"',
+				'"jsonc-parser/lib/esm/main.js"',
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/plugin/index.ts",
+		(contents) =>
+			contents.replace(
+				`  const state = Instance.state(async () => {
+    const client = createOpencodeClient({
+`,
+				`  const state = Instance.state(async () => {
+    if (Flag.OPENCODE_CLIENT === "acp") {
+      log.info("skipping plugin runtime in ACP mode")
+      return {
+        hooks: [],
+        input: {
+          client: undefined as any,
+          project: Instance.project,
+          worktree: Instance.worktree,
+          directory: Instance.directory,
+          serverUrl: "",
+          $: Bun.$,
+        } as PluginInput,
+      }
+    }
+
+    const client = createOpencodeClient({
+`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/session/index.ts",
+		(contents) =>
+			contents
+				.replace('import { SessionPrompt } from "./prompt"\n', "")
+				.replace('import { Command } from "../command"\n', "")
+				.replace(
+					`      const initialize = Effect.fn("Session.initialize")(function* (input: {
+        sessionID: SessionID
+        modelID: ModelID
+        providerID: ProviderID
+        messageID: MessageID
+      }) {
+        yield* Effect.promise(() =>
+          SessionPrompt.command({
+            sessionID: input.sessionID,
+            messageID: input.messageID,
+            model: input.providerID + "/" + input.modelID,
+            command: Command.Default.INIT,
+            arguments: "",
+          }),
+        )
+      })
+`,
+					`      const initialize = Effect.fn("Session.initialize")(function* (input: {
+        sessionID: SessionID
+        modelID: ModelID
+        providerID: ProviderID
+        messageID: MessageID
+      }) {
+        const [{ SessionPrompt }, { Command }] = yield* Effect.promise(() =>
+          Promise.all([import("./prompt"), import("../command")]),
+        )
+        yield* Effect.promise(() =>
+          SessionPrompt.command({
+            sessionID: input.sessionID,
+            messageID: input.messageID,
+            model: input.providerID + "/" + input.modelID,
+            command: Command.Default.INIT,
+            arguments: "",
+          }),
+        )
+      })
+`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/session/prompt.ts",
+		(contents) =>
+			contents
+				.replace(
+					/        const text = yield\* Effect\.promise\(async \(signal\) => \{\n[\s\S]*?          return result\.text\n        \}\)\n/,
+					`        const instanceCtx = yield* InstanceState.context
+        const text = yield* Effect.promise((signal) =>
+          Instance.restore(instanceCtx, async () => {
+            const mdl = ag.model
+              ? await Provider.getModel(ag.model.providerID, ag.model.modelID)
+              : ((await Provider.getSmallModel(input.providerID)) ??
+                (await Provider.getModel(input.providerID, input.modelID)))
+            const msgs = onlySubtasks
+              ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\\n") }]
+              : await MessageV2.toModelMessages(context, mdl)
+            const result = await LLM.stream({
+              agent: ag,
+              user: firstInfo,
+              system: [],
+              small: true,
+              tools: {},
+              model: mdl,
+              abort: signal,
+              sessionID: input.session.id,
+              retries: 2,
+              messages: [{ role: "user", content: "Generate a title for this conversation:\\n" }, ...msgs],
+            })
+            return result.text
+          }),
+        )
+`,
+				)
+				.replace(
+					`      const getModel = (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) =>
+        Effect.promise(() =>
+          Provider.getModel(providerID, modelID).catch((e) => {
+            if (Provider.ModelNotFoundError.isInstance(e)) {
+              const hint = e.data.suggestions?.length ? \` Did you mean: \${e.data.suggestions.join(", ")}?\` : ""
+              Bus.publish(Session.Event.Error, {
+                sessionID,
+                error: new NamedError.Unknown({
+                  message: \`Model not found: \${e.data.providerID}/\${e.data.modelID}.\${hint}\`,
+                }).toObject(),
+              })
+            }
+            throw e
+          }),
+        )
+`,
+					`      const getModel = (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) =>
+        Effect.gen(function* () {
+          const instanceCtx = yield* InstanceState.context
+          return yield* Effect.promise(() =>
+            Instance.restore(instanceCtx, () =>
+              Provider.getModel(providerID, modelID).catch((e) => {
+                if (Provider.ModelNotFoundError.isInstance(e)) {
+                  const hint = e.data.suggestions?.length ? \` Did you mean: \${e.data.suggestions.join(", ")}?\` : ""
+                  Bus.publish(Session.Event.Error, {
+                    sessionID,
+                    error: new NamedError.Unknown({
+                      message: \`Model not found: \${e.data.providerID}/\${e.data.modelID}.\${hint}\`,
+                    }).toObject(),
+                  })
+                }
+                throw e
+              }),
+            ),
+          )
+        })
+`,
+				)
+				.replace(
+					`        const model = input.model ?? ag.model ?? (yield* lastModel(input.sessionID))
+        const full =
+          !input.variant && ag.variant
+            ? yield* Effect.promise(() => Provider.getModel(model.providerID, model.modelID).catch(() => undefined))
+            : undefined
+`,
+					`        const model = input.model ?? ag.model ?? (yield* lastModel(input.sessionID))
+        const instanceCtx = yield* InstanceState.context
+        const full =
+          !input.variant && ag.variant
+            ? yield* Effect.promise(() =>
+                Instance.restore(instanceCtx, () =>
+                  Provider.getModel(model.providerID, model.modelID).catch(() => undefined),
+                ),
+              )
+            : undefined
+`,
+				)
+				.replace(
+					`                      Effect.promise(() => Provider.getModel(info.model.providerID, info.model.modelID)).pipe(
+`,
+					`                      Effect.gen(function* () {
+                        const instanceCtx = yield* InstanceState.context
+                        return yield* Effect.promise(() =>
+                          Instance.restore(instanceCtx, () =>
+                            Provider.getModel(info.model.providerID, info.model.modelID),
+                          ),
+                        )
+                      }).pipe(
+`,
+				)
+				.replace(
+					`                const tools = yield* resolveTools({
+                  agent,
+                  session,
+                  model,
+                  tools: lastUser.tools,
+                  processor: handle,
+                  bypassAgentCheck,
+                  messages: msgs,
+                })
+`,
+					`                const tools = yield* resolveTools({
+                  agent,
+                  session,
+                  model,
+                  tools: lastUser.tools,
+                  processor: handle,
+                  bypassAgentCheck,
+                  messages: msgs,
+                })
+`,
+				)
+				.replace(
+					`                const [skills, env, instructions, modelMsgs] = yield* Effect.promise(() =>
+                  Promise.all([
+                    SystemPrompt.skills(agent),
+                    SystemPrompt.environment(model),
+                    InstructionPrompt.system(),
+                    MessageV2.toModelMessages(msgs, model),
+                  ]),
+                )
+`,
+					`                const instanceCtx = yield* InstanceState.context
+                const [skills, env, instructions, modelMsgs] = yield* Effect.promise(() =>
+                  Instance.restore(instanceCtx, () =>
+                    (async () => {
+                      console.error("[opencode-acp] prompt.system:skills:start", sessionID)
+                      const skills = await Instance.restore(instanceCtx, () => SystemPrompt.skills(agent))
+                      console.error("[opencode-acp] prompt.system:skills:done", sessionID)
+                      console.error("[opencode-acp] prompt.system:env:start", sessionID)
+                      const env = await Instance.restore(instanceCtx, () => SystemPrompt.environment(model))
+                      console.error("[opencode-acp] prompt.system:env:done", sessionID)
+                      console.error("[opencode-acp] prompt.system:instructions:start", sessionID)
+                      const instructions = await Instance.restore(instanceCtx, () => InstructionPrompt.system())
+                      console.error("[opencode-acp] prompt.system:instructions:done", sessionID)
+                      console.error("[opencode-acp] prompt.system:modelMessages:start", sessionID)
+                      const modelMsgs = await Instance.restore(instanceCtx, () =>
+                        MessageV2.toModelMessages(msgs, model),
+                      )
+                      console.error("[opencode-acp] prompt.system:modelMessages:done", sessionID)
+                      return [skills, env, instructions, modelMsgs] as const
+                    })(),
+                  ),
+                )
+`,
+				)
+				.replace(
+					`  const defaultLayer = Layer.unwrap(
+    Effect.sync(() =>
+      layer.pipe(
+        Layer.provide(SessionStatus.layer),
+        Layer.provide(SessionCompaction.defaultLayer),
+        Layer.provide(SessionProcessor.defaultLayer),
+        Layer.provide(Command.defaultLayer),
+        Layer.provide(Permission.layer),
+        Layer.provide(MCP.defaultLayer),
+        Layer.provide(LSP.defaultLayer),
+        Layer.provide(FileTime.defaultLayer),
+        Layer.provide(ToolRegistry.defaultLayer),
+        Layer.provide(Truncate.layer),
+        Layer.provide(AppFileSystem.defaultLayer),
+        Layer.provide(Plugin.defaultLayer),
+        Layer.provide(Session.defaultLayer),
+        Layer.provide(Agent.defaultLayer),
+        Layer.provide(Bus.layer),
+      ),
+    ),
+  )
+`,
+					`  export const defaultLayer = Layer.unwrap(
+    Effect.sync(() =>
+      layer.pipe(
+        Layer.provide(SessionStatus.layer),
+        Layer.provide(SessionCompaction.defaultLayer),
+        Layer.provide(SessionProcessor.defaultLayer),
+        Layer.provide(Command.defaultLayer),
+        Layer.provide(Permission.layer),
+        Layer.provide(MCP.defaultLayer),
+        Layer.provide(LSP.defaultLayer),
+        Layer.provide(FileTime.defaultLayer),
+        Layer.provide(ToolRegistry.defaultLayer),
+        Layer.provide(Truncate.layer),
+        Layer.provide(AppFileSystem.defaultLayer),
+        Layer.provide(Plugin.defaultLayer),
+        Layer.provide(Session.defaultLayer),
+        Layer.provide(Agent.defaultLayer),
+        Layer.provide(Bus.layer),
+      ),
+    ),
+  )
+`,
+				),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/session/llm.ts",
+		(contents) => {
+			let updated = contents;
+			if (
+				!updated.includes(
+					'import { InstanceState } from "@/effect/instance-state"\n',
+				)
+			) {
+				updated = updated.replace(
+					'import { Installation } from "@/installation"\n',
+					'import { Installation } from "@/installation"\nimport { InstanceState } from "@/effect/instance-state"\n',
+				);
+			}
+			updated = updated
+				.replace(
+					`        stream(input) {
+          return Stream.scoped(
+            Stream.unwrap(
+              Effect.gen(function* () {
+                const ctrl = yield* Effect.acquireRelease(
+                  Effect.sync(() => new AbortController()),
+                  (ctrl) => Effect.sync(() => ctrl.abort()),
+                )
+
+                const result = yield* Effect.promise(() => LLM.stream({ ...input, abort: ctrl.signal }))
+
+                return Stream.fromAsyncIterable(result.fullStream, (e) =>
+                  e instanceof Error ? e : new Error(String(e)),
+                )
+              }),
+            ),
+          )
+        },
+`,
+					`        stream(input) {
+          return Stream.scoped(
+            Stream.unwrap(
+              Effect.gen(function* () {
+                const instanceCtx = yield* InstanceState.context
+                const ctrl = yield* Effect.acquireRelease(
+                  Effect.sync(() => new AbortController()),
+                  (ctrl) => Effect.sync(() => ctrl.abort()),
+                )
+
+                const result = yield* Effect.promise(() =>
+                  Instance.restore(instanceCtx, () => LLM.stream({ ...input, abort: ctrl.signal })),
+                )
+
+                return Stream.fromAsyncIterable(result.fullStream, (e) =>
+                  e instanceof Error ? e : new Error(String(e)),
+                )
+              }),
+            ),
+          )
+        },
+`,
+				)
+				.replace(
+					`    const [language, cfg, provider, auth] = await Promise.all([
+      Provider.getLanguage(input.model),
+      Config.get(),
+      Provider.getProvider(input.model.providerID),
+      Auth.get(input.model.providerID),
+    ])
+`,
+					`    const instanceCtx = Instance.current
+    const [language, cfg, provider, auth] = await Instance.restore(instanceCtx, () =>
+      Promise.all([
+        Provider.getLanguage(input.model),
+        Config.get(),
+        Provider.getProvider(input.model.providerID),
+        Auth.get(input.model.providerID),
+      ]),
+    )
+`,
+				)
+				.replace(
+					`    await Plugin.trigger(
+      "experimental.chat.system.transform",
+      { sessionID: input.sessionID, model: input.model },
+      { system },
+    )
+`,
+					`    await Instance.restore(instanceCtx, () =>
+      Plugin.trigger(
+        "experimental.chat.system.transform",
+        { sessionID: input.sessionID, model: input.model },
+        { system },
+      ),
+    )
+`,
+				)
+				.replace(
+					`    const params = await Plugin.trigger(
+      "chat.params",
+      {
+        sessionID: input.sessionID,
+        agent: input.agent.name,
+        model: input.model,
+        provider,
+        message: input.user,
+      },
+      {
+        temperature: input.model.capabilities.temperature
+          ? (input.agent.temperature ?? ProviderTransform.temperature(input.model))
+          : undefined,
+        topP: input.agent.topP ?? ProviderTransform.topP(input.model),
+        topK: ProviderTransform.topK(input.model),
+        options,
+      },
+    )
+`,
+					`    const params = await Instance.restore(instanceCtx, () =>
+      Plugin.trigger(
+        "chat.params",
+        {
+          sessionID: input.sessionID,
+          agent: input.agent.name,
+          model: input.model,
+          provider,
+          message: input.user,
+        },
+        {
+          temperature: input.model.capabilities.temperature
+            ? (input.agent.temperature ?? ProviderTransform.temperature(input.model))
+            : undefined,
+          topP: input.agent.topP ?? ProviderTransform.topP(input.model),
+          topK: ProviderTransform.topK(input.model),
+          options,
+        },
+      ),
+    )
+`,
+				)
+				.replace(
+					`    const { headers } = await Plugin.trigger(
+      "chat.headers",
+      {
+        sessionID: input.sessionID,
+        agent: input.agent.name,
+        model: input.model,
+        provider,
+        message: input.user,
+      },
+      {
+        headers: {},
+      },
+    )
+`,
+					`    const { headers } = await Instance.restore(instanceCtx, () =>
+      Plugin.trigger(
+        "chat.headers",
+        {
+          sessionID: input.sessionID,
+          agent: input.agent.name,
+          model: input.model,
+          provider,
+          message: input.user,
+        },
+        {
+          headers: {},
+        },
+      ),
+    )
+`,
+				)
+				.replace(
+					`    const tools = await resolveTools(input)
+`,
+					`    const tools = await Instance.restore(instanceCtx, () => resolveTools(input))
+`,
+				)
+				.replace(
+					`      headers: {
+        ...(input.model.providerID.startsWith("opencode")
+          ? {
+              "x-opencode-project": Instance.project.id,
+              "x-opencode-session": input.sessionID,
+              "x-opencode-request": input.user.id,
+              "x-opencode-client": Flag.OPENCODE_CLIENT,
+            }
+          : {
+              "User-Agent": \`opencode/\${Installation.VERSION}\`,
+            }),
+        ...input.model.headers,
+        ...headers,
+      },
+`,
+					`      headers: {
+        ...(input.model.providerID.startsWith("opencode")
+          ? Instance.restore(instanceCtx, () => ({
+              "x-opencode-project": Instance.project.id,
+              "x-opencode-session": input.sessionID,
+              "x-opencode-request": input.user.id,
+              "x-opencode-client": Flag.OPENCODE_CLIENT,
+            }))
+          : {
+              "User-Agent": \`opencode/\${Installation.VERSION}\`,
+            }),
+        ...input.model.headers,
+        ...headers,
+      },
+`,
+				)
+				.replace(
+					`    return streamText({
+`,
+					`    return Instance.restore(instanceCtx, () => streamText({
+`,
+				)
+				.replace(
+					`    })
+  }
+`,
+					`    }))
+  }
+`,
+				);
+			return updated;
+		},
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/session/prompt.ts",
+		(contents) =>
+			contents.replace(
+				`            execute(args, options) {
+              return Effect.runPromise(
+                Effect.gen(function* () {
+                  const ctx = context(args, options)
+                  yield* plugin.trigger(
+                    "tool.execute.before",
+                    { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
+                    { args },
+                  )
+                  const result = yield* Effect.promise(() => item.execute(args, ctx))
+                  const output = {
+                    ...result,
+                    attachments: result.attachments?.map((attachment) => ({
+                      ...attachment,
+                      id: PartID.ascending(),
+                      sessionID: ctx.sessionID,
+                      messageID: input.processor.message.id,
+                    })),
+                  }
+                  yield* plugin.trigger(
+                    "tool.execute.after",
+                    { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
+                    output,
+                  )
+                  return output
+                }),
+              )
+            },
+`,
+				`            execute(args, options) {
+              const instanceCtx =
+                ((globalThis as typeof globalThis & { __agentosOpencodeInstanceFallback?: unknown })
+                  .__agentosOpencodeInstanceFallback ??
+                  Instance.current) as any
+              return Instance.restore(instanceCtx, () =>
+                Effect.runPromise(
+                  Effect.gen(function* () {
+                    const ctx = context(args, options)
+                    yield* plugin.trigger(
+                      "tool.execute.before",
+                      { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID },
+                      { args },
+                    )
+                    const result = yield* Effect.promise(() => item.execute(args, ctx))
+                    const output = {
+                      ...result,
+                      attachments: result.attachments?.map((attachment) => ({
+                        ...attachment,
+                        id: PartID.ascending(),
+                        sessionID: ctx.sessionID,
+                        messageID: input.processor.message.id,
+                      })),
+                    }
+                    yield* plugin.trigger(
+                      "tool.execute.after",
+                      { tool: item.id, sessionID: ctx.sessionID, callID: ctx.callID, args },
+                      output,
+                    )
+                    return output
+                  }),
+                ),
+              )
+            },
+`,
+			),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/session/instruction.ts",
+		(contents) =>
+			contents
+				.replace(
+					`async function resolveRelative(instruction: string): Promise<string[]> {
+  if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+    return Filesystem.globUp(instruction, Instance.directory, Instance.worktree).catch(() => [])
+  }
+  if (!Flag.OPENCODE_CONFIG_DIR) {
+    log.warn(
+      \`Skipping relative instruction "\${instruction}" - no OPENCODE_CONFIG_DIR set while project config is disabled\`,
+    )
+    return []
+  }
+  return Filesystem.globUp(instruction, Flag.OPENCODE_CONFIG_DIR, Flag.OPENCODE_CONFIG_DIR).catch(() => [])
+}
+`,
+					`async function resolveRelative(instruction: string): Promise<string[]> {
+  const ctx = Instance.current
+  if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+    return Instance.restore(ctx, () =>
+      Filesystem.globUp(instruction, ctx.directory, ctx.worktree).catch(() => []),
+    )
+  }
+  if (!Flag.OPENCODE_CONFIG_DIR) {
+    log.warn(
+      \`Skipping relative instruction "\${instruction}" - no OPENCODE_CONFIG_DIR set while project config is disabled\`,
+    )
+    return []
+  }
+  return Filesystem.globUp(instruction, Flag.OPENCODE_CONFIG_DIR, Flag.OPENCODE_CONFIG_DIR).catch(() => [])
+}
+`,
+				)
+				.replace(
+					`  export async function systemPaths() {
+    const config = await Config.get()
+`,
+					`  export async function systemPaths() {
+    const ctx = Instance.current
+    const config = await Instance.restore(ctx, () => Config.get())
+`,
+				)
+				.replace(
+					`        const matches = await Filesystem.findUp(file, Instance.directory, Instance.worktree)
+`,
+					`        const matches = await Instance.restore(ctx, () =>
+          Filesystem.findUp(file, ctx.directory, ctx.worktree),
+        )
+`,
+				)
+				.replace(
+					`          : await resolveRelative(instruction)
+`,
+					`          : await Instance.restore(ctx, () => resolveRelative(instruction))
+`,
+				)
+				.replace(
+					`  export async function system() {
+    const config = await Config.get()
+    const paths = await systemPaths()
+`,
+					`  export async function system() {
+    const ctx = Instance.current
+    const config = await Instance.restore(ctx, () => Config.get())
+    const paths = await Instance.restore(ctx, () => systemPaths())
+`,
+				)
+				.replace(
+					`  export async function resolve(messages: MessageV2.WithParts[], filepath: string, messageID: string) {
+    const system = await systemPaths()
+    const already = loaded(messages)
+    const results: { filepath: string; content: string }[] = []
+
+    const target = path.resolve(filepath)
+    let current = path.dirname(target)
+    const root = path.resolve(Instance.directory)
+`,
+					`  export async function resolve(messages: MessageV2.WithParts[], filepath: string, messageID: string) {
+    const ctx = Instance.current
+    const system = await Instance.restore(ctx, () => systemPaths())
+    const already = loaded(messages)
+    const results: { filepath: string; content: string }[] = []
+
+    const target = path.resolve(filepath)
+    let current = path.dirname(target)
+    const root = path.resolve(ctx.directory)
+`,
+				),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/provider/provider.ts",
+		(contents) =>
+			contents
+				.replace(
+					'import { Config } from "../config/config"\n',
+					'import { Config } from "../config/config"\nimport { Instance } from "../project/instance"\n',
+				)
+				.replace(
+					`  async function loadProviders() {
+    const cfg = await Config.get()
+`,
+					`  async function loadProviders() {
+    const ctx = Instance.current
+    const cfg = await Instance.restore(ctx, () => Config.get())
+`,
+				)
+				.replace(
+					`  export async function defaultModel() {
+    const cfg = await Config.get()
+`,
+					`  export async function defaultModel() {
+    const ctx = Instance.current
+    const cfg = await Instance.restore(ctx, () => Config.get())
+`,
+				)
+				.replace(
+					`    const providers = await loadProviders()
+    for (const provider of Object.values(providers)) {
+`,
+					`    const providers = await Instance.restore(ctx, () => loadProviders())
+    for (const provider of Object.values(providers)) {
+`,
+				),
+		);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/effect/instance-state.ts",
+		(contents) =>
+			contents.replace(
+				`    const fiber = Fiber.getCurrent()
+    const ctx = fiber ? ServiceMap.getReferenceUnsafe(fiber.services, InstanceRef) : undefined
+    if (!ctx) return fn
+    return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
+`,
+				`    const fiber = Fiber.getCurrent()
+    const ctx = fiber ? ServiceMap.getReferenceUnsafe(fiber.services, InstanceRef) : undefined
+    const fallback = (globalThis as typeof globalThis & { __agentosOpencodeInstanceFallback?: unknown })
+      .__agentosOpencodeInstanceFallback as typeof ctx
+    const boundCtx = ctx ?? fallback
+    if (!boundCtx) return fn
+    return ((...args: any[]) => Instance.restore(boundCtx, () => fn(...args))) as F
+`,
+			).replace(
+				`  export const context = Effect.fnUntraced(function* () {
+    return (yield* InstanceRef) ?? Instance.current
+  })()
+`,
+				`  export const context = Effect.fnUntraced(function* () {
+    const ref = yield* InstanceRef
+    if (ref) return ref
+    const fallback = (globalThis as typeof globalThis & { __agentosOpencodeInstanceFallback?: unknown })
+      .__agentosOpencodeInstanceFallback
+    if (fallback) return fallback as typeof ref
+    try {
+      return Instance.current
+    } catch (error) {
+      console.error("[opencode-acp] missing-instance-context", new Error().stack)
+      throw error
+    }
+  })()
+`,
+			),
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/effect/run-service.ts"),
+		`import { Effect, Layer, ManagedRuntime } from "effect"
+import * as ServiceMap from "effect/ServiceMap"
+import { Instance } from "@/project/instance"
+import { Context } from "@/util/context"
+import { InstanceRef } from "./instance-ref"
+
+export const memoMap = Layer.makeMemoMapUnsafe()
+
+function attach<A, E, R>(effect: Effect.Effect<A, E, R>) {
+  try {
+    const ctx = Instance.current
+    return {
+      ctx,
+      effect: Effect.provideService(effect, InstanceRef, ctx),
+    }
+  } catch (err) {
+    if (!(err instanceof Context.NotFound)) throw err
+  }
+  return { ctx: undefined, effect }
+}
+
+export function makeRuntime<I, S, E>(service: ServiceMap.Service<I, S>, layer: Layer.Layer<I, E>) {
+  let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
+  const getRuntime = () => (rt ??= ManagedRuntime.make(layer, { memoMap }))
+
+  return {
+    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => {
+      const attached = attach(service.use(fn))
+      return attached.ctx
+        ? Instance.restore(attached.ctx, () => getRuntime().runSync(attached.effect))
+        : getRuntime().runSync(attached.effect)
+    },
+    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => {
+      const attached = attach(service.use(fn))
+      return attached.ctx
+        ? Instance.restore(attached.ctx, () => getRuntime().runPromiseExit(attached.effect, options))
+        : getRuntime().runPromiseExit(attached.effect, options)
+    },
+    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => {
+      const attached = attach(service.use(fn))
+      return attached.ctx
+        ? Instance.restore(attached.ctx, () => getRuntime().runPromise(attached.effect, options))
+        : getRuntime().runPromise(attached.effect, options)
+    },
+    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => {
+      const attached = attach(service.use(fn))
+      return attached.ctx
+        ? Instance.restore(attached.ctx, () => getRuntime().runFork(attached.effect))
+        : getRuntime().runFork(attached.effect)
+    },
+    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => {
+      const attached = attach(service.use(fn))
+      return attached.ctx
+        ? Instance.restore(attached.ctx, () => getRuntime().runCallback(attached.effect))
+        : getRuntime().runCallback(attached.effect)
+    },
+  }
+}
+`,
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/tool/tool.ts",
+		(contents) =>
+			contents
+				.replace(
+					'import { Truncate } from "./truncate"\n',
+					'import { Truncate } from "./truncate"\nimport { InstanceState } from "@/effect/instance-state"\n',
+				)
+				.replace(
+					`        const toolInfo = init instanceof Function ? await init(initCtx) : init
+        const execute = toolInfo.execute
+        toolInfo.execute = async (args, ctx) => {
+`,
+					`        const toolInfo =
+          init instanceof Function ? await InstanceState.bind(() => init(initCtx))() : init
+        const execute = toolInfo.execute
+        toolInfo.execute = InstanceState.bind(async (args, ctx) => {
+`,
+				)
+				.replace(
+					`        }
+        return toolInfo
+`,
+					`        })
+        return toolInfo
+`,
+				),
+		);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/storage/db.ts",
+		(contents) =>
+			contents.replace(
+				`    db.run("PRAGMA journal_mode = WAL")
+    db.run("PRAGMA synchronous = NORMAL")
+    db.run("PRAGMA busy_timeout = 5000")
+    db.run("PRAGMA cache_size = -64000")
+    db.run("PRAGMA foreign_keys = ON")
+    db.run("PRAGMA wal_checkpoint(PASSIVE)")`,
+				`    db.$client.exec("PRAGMA journal_mode = WAL")
+    db.$client.exec("PRAGMA synchronous = NORMAL")
+    db.$client.exec("PRAGMA busy_timeout = 5000")
+    db.$client.exec("PRAGMA cache_size = -64000")
+    db.$client.exec("PRAGMA foreign_keys = ON")
+    db.$client.exec("PRAGMA wal_checkpoint(PASSIVE)")`,
+			),
+	);
+}
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/provider/provider.ts",
+		(contents) =>
+			contents
+				.replace(
+					`// Direct imports for bundled providers
+import { createAmazonBedrock, type AmazonBedrockProviderSettings } from "@ai-sdk/amazon-bedrock"
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createAzure } from "@ai-sdk/azure"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { createVertex } from "@ai-sdk/google-vertex"
+import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic"
+import { createOpenAI } from "@ai-sdk/openai"
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+import { createOpenRouter, type LanguageModelV2 } from "@openrouter/ai-sdk-provider"
+import { createOpenaiCompatible as createGitHubCopilotOpenAICompatible } from "./sdk/openai-compatible/src"
+import { createXai } from "@ai-sdk/xai"
+import { createMistral } from "@ai-sdk/mistral"
+import { createGroq } from "@ai-sdk/groq"
+import { createDeepInfra } from "@ai-sdk/deepinfra"
+import { createCerebras } from "@ai-sdk/cerebras"
+import { createCohere } from "@ai-sdk/cohere"
+import { createGateway } from "@ai-sdk/gateway"
+import { createTogetherAI } from "@ai-sdk/togetherai"
+import { createPerplexity } from "@ai-sdk/perplexity"
+import { createVercel } from "@ai-sdk/vercel"
+import { createGitLab } from "@gitlab/gitlab-ai-provider"
+import { ProviderTransform } from "./transform"
+`,
+					`import type { LanguageModelV2 } from "@openrouter/ai-sdk-provider"
+import { ProviderTransform } from "./transform"
+`,
+				)
+				.replace(
+					`  const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
+    "@ai-sdk/amazon-bedrock": createAmazonBedrock,
+    "@ai-sdk/anthropic": createAnthropic,
+    "@ai-sdk/azure": createAzure,
+    "@ai-sdk/google": createGoogleGenerativeAI,
+    "@ai-sdk/google-vertex": createVertex,
+    "@ai-sdk/google-vertex/anthropic": createVertexAnthropic,
+    "@ai-sdk/openai": createOpenAI,
+    "@ai-sdk/openai-compatible": createOpenAICompatible,
+    "@openrouter/ai-sdk-provider": createOpenRouter,
+    "@ai-sdk/xai": createXai,
+    "@ai-sdk/mistral": createMistral,
+    "@ai-sdk/groq": createGroq,
+    "@ai-sdk/deepinfra": createDeepInfra,
+    "@ai-sdk/cerebras": createCerebras,
+    "@ai-sdk/cohere": createCohere,
+    "@ai-sdk/gateway": createGateway,
+    "@ai-sdk/togetherai": createTogetherAI,
+    "@ai-sdk/perplexity": createPerplexity,
+    "@ai-sdk/vercel": createVercel,
+    "@gitlab/gitlab-ai-provider": createGitLab,
+    // @ts-ignore (TODO: kill this code so we dont have to maintain it)
+    "@ai-sdk/github-copilot": createGitHubCopilotOpenAICompatible,
+  }
+`,
+					`  const BUNDLED_PROVIDERS: Record<string, (options: any) => Promise<SDK>> = {
+    "@ai-sdk/amazon-bedrock": async (options) =>
+      (await import("@ai-sdk/amazon-bedrock")).createAmazonBedrock(options),
+    "@ai-sdk/anthropic": async (options) => (await import("@ai-sdk/anthropic")).createAnthropic(options),
+    "@ai-sdk/azure": async (options) => (await import("@ai-sdk/azure")).createAzure(options),
+    "@ai-sdk/google": async (options) => (await import("@ai-sdk/google")).createGoogleGenerativeAI(options),
+    "@ai-sdk/google-vertex": async (options) => (await import("@ai-sdk/google-vertex")).createVertex(options),
+    "@ai-sdk/google-vertex/anthropic": async (options) =>
+      (await import("@ai-sdk/google-vertex/anthropic")).createVertexAnthropic(options),
+    "@ai-sdk/openai": async (options) => (await import("@ai-sdk/openai")).createOpenAI(options),
+    "@ai-sdk/openai-compatible": async (options) =>
+      (await import("@ai-sdk/openai-compatible")).createOpenAICompatible(options),
+    "@openrouter/ai-sdk-provider": async (options) =>
+      (await import("@openrouter/ai-sdk-provider")).createOpenRouter(options),
+    "@ai-sdk/xai": async (options) => (await import("@ai-sdk/xai")).createXai(options),
+    "@ai-sdk/mistral": async (options) => (await import("@ai-sdk/mistral")).createMistral(options),
+    "@ai-sdk/groq": async (options) => (await import("@ai-sdk/groq")).createGroq(options),
+    "@ai-sdk/deepinfra": async (options) => (await import("@ai-sdk/deepinfra")).createDeepInfra(options),
+    "@ai-sdk/cerebras": async (options) => (await import("@ai-sdk/cerebras")).createCerebras(options),
+    "@ai-sdk/cohere": async (options) => (await import("@ai-sdk/cohere")).createCohere(options),
+    "@ai-sdk/gateway": async (options) => (await import("@ai-sdk/gateway")).createGateway(options),
+    "@ai-sdk/togetherai": async (options) => (await import("@ai-sdk/togetherai")).createTogetherAI(options),
+    "@ai-sdk/perplexity": async (options) => (await import("@ai-sdk/perplexity")).createPerplexity(options),
+    "@ai-sdk/vercel": async (options) => (await import("@ai-sdk/vercel")).createVercel(options),
+    "@gitlab/gitlab-ai-provider": async (options) =>
+      (await import("@gitlab/gitlab-ai-provider")).createGitLab(options),
+    "@ai-sdk/github-copilot": async (options) =>
+      (await import("./sdk/openai-compatible/src")).createOpenaiCompatible(options),
+  }
+`,
+				)
+				.replace(
+					"        async getModel(sdk: ReturnType<typeof createGitLab>, modelID: string) {\n",
+					"        async getModel(sdk: any, modelID: string) {\n",
+				)
+				.replace(
+					`        const loaded = bundledFn({
+          name: model.providerID,
+          ...options,
+        })
+`,
+					`        const loaded = await bundledFn({
+          name: model.providerID,
+          ...options,
+        })
+`,
+				),
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/provider/provider.ts"),
+		`import z from "zod"
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { createVertex } from "@ai-sdk/google-vertex"
+import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic"
+import { createGroq } from "@ai-sdk/groq"
+import { createMistral } from "@ai-sdk/mistral"
+import { createOpenAI } from "@ai-sdk/openai"
+import type { LanguageModelV3 } from "@ai-sdk/provider"
+import { NamedError } from "@opencode-ai/util/error"
+import { Config } from "../config/config"
+import { ModelID, ProviderID } from "./schema"
+
+type ProviderConfig = {
+  name?: string
+  env?: string[]
+  npm?: string
+  api?: string
+  options?: Record<string, any>
+  models?: Record<string, any>
+}
+
+type ProviderSeed = {
+  name: string
+  env: string[]
+  npm: string
+  models: Array<{
+    id: string
+    name: string
+    family?: string
+    reasoning?: boolean
+    attachment?: boolean
+    input?: Partial<{ text: boolean; audio: boolean; image: boolean; video: boolean; pdf: boolean }>
+    output?: Partial<{ text: boolean; audio: boolean; image: boolean; video: boolean; pdf: boolean }>
+    limit?: Partial<{ context: number; input: number; output: number }>
+    cost?: Partial<{
+      input: number
+      output: number
+      cache: Partial<{ read: number; write: number }>
+    }>
+    releaseDate?: string
+  }>
+}
+
+export namespace Provider {
+  export const Model = z
+    .object({
+      id: ModelID.zod,
+      providerID: ProviderID.zod,
+      api: z.object({
+        id: z.string(),
+        url: z.string(),
+        npm: z.string(),
+      }),
+      name: z.string(),
+      family: z.string().optional(),
+      capabilities: z.object({
+        temperature: z.boolean(),
+        reasoning: z.boolean(),
+        attachment: z.boolean(),
+        toolcall: z.boolean(),
+        input: z.object({
+          text: z.boolean(),
+          audio: z.boolean(),
+          image: z.boolean(),
+          video: z.boolean(),
+          pdf: z.boolean(),
+        }),
+        output: z.object({
+          text: z.boolean(),
+          audio: z.boolean(),
+          image: z.boolean(),
+          video: z.boolean(),
+          pdf: z.boolean(),
+        }),
+        interleaved: z.union([
+          z.boolean(),
+          z.object({
+            field: z.enum(["reasoning_content", "reasoning_details"]),
+          }),
+        ]),
+      }),
+      cost: z.object({
+        input: z.number(),
+        output: z.number(),
+        cache: z.object({
+          read: z.number(),
+          write: z.number(),
+        }),
+        experimentalOver200K: z
+          .object({
+            input: z.number(),
+            output: z.number(),
+            cache: z.object({
+              read: z.number(),
+              write: z.number(),
+            }),
+          })
+          .optional(),
+      }),
+      limit: z.object({
+        context: z.number(),
+        input: z.number().optional(),
+        output: z.number(),
+      }),
+      status: z.enum(["alpha", "beta", "deprecated", "active"]),
+      options: z.record(z.string(), z.any()),
+      headers: z.record(z.string(), z.string()),
+      release_date: z.string(),
+      variants: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+    })
+    .meta({
+      ref: "Model",
+    })
+  export type Model = z.infer<typeof Model>
+
+  export const Info = z
+    .object({
+      id: ProviderID.zod,
+      name: z.string(),
+      source: z.enum(["env", "config", "custom", "api"]),
+      env: z.string().array(),
+      key: z.string().optional(),
+      options: z.record(z.string(), z.any()),
+      models: z.record(z.string(), Model),
+    })
+    .meta({
+      ref: "Provider",
+    })
+  export type Info = z.infer<typeof Info>
+
+  const DEFAULT_CONTEXT_LIMIT = 200_000
+  const DEFAULT_OUTPUT_LIMIT = 32_000
+
+  const PROVIDER_SEEDS: Record<string, ProviderSeed> = {
+    anthropic: {
+      name: "Anthropic",
+      env: ["ANTHROPIC_API_KEY"],
+      npm: "@ai-sdk/anthropic",
+      models: [
+        {
+          id: "claude-sonnet-4-20250514",
+          name: "Claude Sonnet 4",
+          family: "claude-sonnet-4",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-05-14",
+        },
+        {
+          id: "claude-opus-4-1-20250805",
+          name: "Claude Opus 4.1",
+          family: "claude-opus-4-1",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-08-05",
+        },
+        {
+          id: "claude-haiku-4-5-20251001",
+          name: "Claude Haiku 4.5",
+          family: "claude-haiku-4-5",
+          reasoning: false,
+          attachment: true,
+          input: { image: true, pdf: true },
+          limit: { output: 16_000 },
+          releaseDate: "2025-10-01",
+        },
+      ],
+    },
+    openai: {
+      name: "OpenAI",
+      env: ["OPENAI_API_KEY"],
+      npm: "@ai-sdk/openai",
+      models: [
+        {
+          id: "gpt-5",
+          name: "GPT-5",
+          family: "gpt-5",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-01-01",
+        },
+        {
+          id: "gpt-5-mini",
+          name: "GPT-5 Mini",
+          family: "gpt-5-mini",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          limit: { output: 16_000 },
+          releaseDate: "2025-01-01",
+        },
+        {
+          id: "gpt-5-nano",
+          name: "GPT-5 Nano",
+          family: "gpt-5-nano",
+          reasoning: false,
+          attachment: true,
+          input: { image: true, pdf: true },
+          limit: { output: 8_000 },
+          releaseDate: "2025-01-01",
+        },
+      ],
+    },
+    google: {
+      name: "Google",
+      env: ["GOOGLE_GENERATIVE_AI_API_KEY"],
+      npm: "@ai-sdk/google",
+      models: [
+        {
+          id: "gemini-2.5-pro",
+          name: "Gemini 2.5 Pro",
+          family: "gemini-2.5-pro",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-01-01",
+        },
+        {
+          id: "gemini-2.5-flash",
+          name: "Gemini 2.5 Flash",
+          family: "gemini-2.5-flash",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          limit: { output: 16_000 },
+          releaseDate: "2025-01-01",
+        },
+      ],
+    },
+    "google-vertex": {
+      name: "Google Vertex",
+      env: [],
+      npm: "@ai-sdk/google-vertex",
+      models: [
+        {
+          id: "gemini-2.5-pro",
+          name: "Gemini 2.5 Pro",
+          family: "gemini-2.5-pro",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-01-01",
+        },
+      ],
+    },
+    groq: {
+      name: "Groq",
+      env: ["GROQ_API_KEY"],
+      npm: "@ai-sdk/groq",
+      models: [
+        {
+          id: "llama-3.3-70b-versatile",
+          name: "Llama 3.3 70B Versatile",
+          family: "llama-3.3-70b",
+          reasoning: true,
+          releaseDate: "2025-01-01",
+        },
+      ],
+    },
+    mistral: {
+      name: "Mistral",
+      env: ["MISTRAL_API_KEY"],
+      npm: "@ai-sdk/mistral",
+      models: [
+        {
+          id: "mistral-small-latest",
+          name: "Mistral Small Latest",
+          family: "mistral-small",
+          reasoning: true,
+          attachment: true,
+          input: { image: true, pdf: true },
+          releaseDate: "2025-01-01",
+        },
+      ],
+    },
+  }
+
+  const providerCache = new Map<string, any>()
+  const languageCache = new Map<string, LanguageModelV3>()
+  const SDK_FACTORIES: Record<string, (options: Record<string, any>) => any> = {
+    "@ai-sdk/anthropic": createAnthropic,
+    "@ai-sdk/google": createGoogleGenerativeAI,
+    "@ai-sdk/google-vertex": createVertex,
+    "@ai-sdk/google-vertex/anthropic": createVertexAnthropic,
+    "@ai-sdk/groq": createGroq,
+    "@ai-sdk/mistral": createMistral,
+    "@ai-sdk/openai": createOpenAI,
+  }
+  const priority = ["gpt-5", "claude-sonnet-4", "big-pickle", "gemini-3-pro"]
+
+  function firstEnv(names: string[]) {
+    for (const name of names) {
+      const value = process.env[name]
+      if (typeof value === "string" && value.length > 0) {
+        return value
+      }
+    }
+    return undefined
+  }
+
+  function cloneRecord<T extends Record<string, any>>(value: T | undefined): T {
+    return { ...(value ?? ({} as T)) }
+  }
+
+  function buildModel(
+    providerID: ProviderID,
+    seed: ProviderSeed,
+    input: {
+      id: string
+      name?: string
+      family?: string
+      reasoning?: boolean
+      attachment?: boolean
+      toolCall?: boolean
+      status?: "alpha" | "beta" | "deprecated" | "active"
+      input?: Partial<{ text: boolean; audio: boolean; image: boolean; video: boolean; pdf: boolean }>
+      output?: Partial<{ text: boolean; audio: boolean; image: boolean; video: boolean; pdf: boolean }>
+      limit?: Partial<{ context: number; input: number; output: number }>
+      cost?: Partial<{
+        input: number
+        output: number
+        cache: Partial<{ read: number; write: number }>
+      }>
+      headers?: Record<string, string>
+      options?: Record<string, any>
+      api?: {
+        id?: string
+        url?: string
+        npm?: string
+      }
+      releaseDate?: string
+      variants?: Record<string, Record<string, any>>
+    },
+  ): Model {
+    return {
+      id: ModelID.make(input.id),
+      providerID,
+      api: {
+        id: input.api?.id ?? input.id,
+        url: input.api?.url ?? "",
+        npm: input.api?.npm ?? seed.npm,
+      },
+      name: input.name ?? input.id,
+      family: input.family,
+      capabilities: {
+        temperature: true,
+        reasoning: input.reasoning ?? false,
+        attachment: input.attachment ?? false,
+        toolcall: input.toolCall ?? true,
+        input: {
+          text: input.input?.text ?? true,
+          audio: input.input?.audio ?? false,
+          image: input.input?.image ?? false,
+          video: input.input?.video ?? false,
+          pdf: input.input?.pdf ?? false,
+        },
+        output: {
+          text: input.output?.text ?? true,
+          audio: input.output?.audio ?? false,
+          image: input.output?.image ?? false,
+          video: input.output?.video ?? false,
+          pdf: input.output?.pdf ?? false,
+        },
+        interleaved: false,
+      },
+      cost: {
+        input: input.cost?.input ?? 0,
+        output: input.cost?.output ?? 0,
+        cache: {
+          read: input.cost?.cache?.read ?? 0,
+          write: input.cost?.cache?.write ?? 0,
+        },
+      },
+      limit: {
+        context: input.limit?.context ?? DEFAULT_CONTEXT_LIMIT,
+        ...(input.limit?.input !== undefined ? { input: input.limit.input } : {}),
+        output: input.limit?.output ?? DEFAULT_OUTPUT_LIMIT,
+      },
+      status: input.status ?? "active",
+      options: cloneRecord(input.options),
+      headers: cloneRecord(input.headers),
+      release_date: input.releaseDate ?? "2025-01-01",
+      variants: input.variants ?? {},
+    }
+  }
+
+  function buildSeedModels(providerID: ProviderID, seed: ProviderSeed) {
+    return Object.fromEntries(
+      seed.models.map((model) => [model.id, buildModel(providerID, seed, model)]),
+    ) as Record<string, Model>
+  }
+
+  function applyConfiguredModels(
+    providerID: ProviderID,
+    seed: ProviderSeed,
+    provider: Info,
+    configuredProvider: ProviderConfig | undefined,
+  ) {
+    for (const [modelID, raw] of Object.entries(configuredProvider?.models ?? {})) {
+      const existing = provider.models[modelID]
+      provider.models[modelID] = buildModel(providerID, seed, {
+        id: modelID,
+        name: raw?.name ?? existing?.name ?? modelID,
+        family: raw?.family ?? existing?.family,
+        reasoning: raw?.reasoning ?? existing?.capabilities.reasoning ?? false,
+        attachment: raw?.attachment ?? existing?.capabilities.attachment ?? false,
+        toolCall: raw?.tool_call ?? existing?.capabilities.toolcall ?? true,
+        status: raw?.status ?? existing?.status ?? "active",
+        input: {
+          text: raw?.modalities?.input?.includes("text") ?? existing?.capabilities.input.text ?? true,
+          audio: raw?.modalities?.input?.includes("audio") ?? existing?.capabilities.input.audio ?? false,
+          image: raw?.modalities?.input?.includes("image") ?? existing?.capabilities.input.image ?? false,
+          video: raw?.modalities?.input?.includes("video") ?? existing?.capabilities.input.video ?? false,
+          pdf: raw?.modalities?.input?.includes("pdf") ?? existing?.capabilities.input.pdf ?? false,
+        },
+        output: {
+          text: raw?.modalities?.output?.includes("text") ?? existing?.capabilities.output.text ?? true,
+          audio: raw?.modalities?.output?.includes("audio") ?? existing?.capabilities.output.audio ?? false,
+          image: raw?.modalities?.output?.includes("image") ?? existing?.capabilities.output.image ?? false,
+          video: raw?.modalities?.output?.includes("video") ?? existing?.capabilities.output.video ?? false,
+          pdf: raw?.modalities?.output?.includes("pdf") ?? existing?.capabilities.output.pdf ?? false,
+        },
+        limit: {
+          context: raw?.limit?.context ?? existing?.limit.context,
+          input: raw?.limit?.input ?? existing?.limit.input,
+          output: raw?.limit?.output ?? existing?.limit.output,
+        },
+        cost: {
+          input: raw?.cost?.input ?? existing?.cost.input,
+          output: raw?.cost?.output ?? existing?.cost.output,
+          cache: {
+            read: raw?.cost?.cache_read ?? existing?.cost.cache.read,
+            write: raw?.cost?.cache_write ?? existing?.cost.cache.write,
+          },
+        },
+        headers: {
+          ...existing?.headers,
+          ...cloneRecord(raw?.headers),
+        },
+        options: {
+          ...existing?.options,
+          ...cloneRecord(raw?.options),
+        },
+        api: {
+          id: raw?.id ?? existing?.api.id ?? modelID,
+          url: raw?.provider?.api ?? configuredProvider?.api ?? existing?.api.url ?? "",
+          npm: raw?.provider?.npm ?? configuredProvider?.npm ?? existing?.api.npm ?? seed.npm,
+        },
+        releaseDate: raw?.release_date ?? existing?.release_date,
+        variants: raw?.variants ?? existing?.variants,
+      })
+    }
+  }
+
+  async function loadProviders() {
+    const cfg = await Config.get()
+    const configured = (cfg.provider ?? {}) as Record<string, ProviderConfig>
+    const providers: Record<string, Info> = {}
+
+    for (const [providerName, seed] of Object.entries(PROVIDER_SEEDS)) {
+      const providerID = ProviderID.make(providerName)
+      const configuredProvider = configured[providerName]
+      const configuredModel = typeof cfg.model === "string" && cfg.model.startsWith(providerName + "/")
+      const key = firstEnv(configuredProvider?.env ?? seed.env) ?? configuredProvider?.options?.apiKey
+
+      if (!configuredProvider && !configuredModel && !key) {
+        continue
+      }
+
+      const info: Info = {
+        id: providerID,
+        name: configuredProvider?.name ?? seed.name,
+        source: configuredProvider ? "config" : key ? "env" : "custom",
+        env: configuredProvider?.env ?? seed.env,
+        ...(typeof key === "string" && key.length > 0 ? { key } : {}),
+        options: {
+          ...cloneRecord(configuredProvider?.options),
+        },
+        models: buildSeedModels(providerID, seed),
+      }
+
+      applyConfiguredModels(providerID, seed, info, configuredProvider)
+      providers[providerID] = info
+    }
+
+    if (Object.keys(providers).length === 0) {
+      const fallback = PROVIDER_SEEDS.anthropic
+      providers[ProviderID.anthropic] = {
+        id: ProviderID.anthropic,
+        name: fallback.name,
+        source: "custom",
+        env: fallback.env,
+        options: {},
+        models: buildSeedModels(ProviderID.anthropic, fallback),
+      }
+    }
+
+    return providers as Record<ProviderID, Info>
+  }
+
+  function modelKey(providerID: ProviderID, modelID: ModelID) {
+    return String(providerID) + "/" + String(modelID)
+  }
+
+  export async function list() {
+    return loadProviders()
+  }
+
+  export async function getProvider(providerID: ProviderID) {
+    const providers = await loadProviders()
+    const provider = providers[providerID]
+    if (!provider) {
+      throw new InitError({ providerID })
+    }
+    return provider
+  }
+
+  export async function getModel(providerID: ProviderID, modelID: ModelID) {
+    const provider = await getProvider(providerID)
+    const model = provider.models[modelID]
+    if (model) return model
+
+    const suggestions = Object.keys(provider.models).filter(
+      (candidate) => candidate.includes(String(modelID)) || String(modelID).includes(candidate),
+    )
+    throw new ModelNotFoundError({
+      providerID,
+      modelID,
+      ...(suggestions.length ? { suggestions: suggestions.slice(0, 3) } : {}),
+    })
+  }
+
+  async function getSdk(provider: Info, model: Model) {
+    const cacheKey = JSON.stringify({
+      providerID: provider.id,
+      apiId: model.api.id,
+      baseURL: provider.options?.baseURL,
+      headers: provider.options?.headers,
+      key: provider.key,
+    })
+    if (providerCache.has(cacheKey)) {
+      return providerCache.get(cacheKey)
+    }
+
+    const options = {
+      ...cloneRecord(provider.options),
+      ...(provider.key ? { apiKey: provider.key } : {}),
+      headers: {
+        ...cloneRecord(provider.options?.headers),
+        ...cloneRecord(model.headers),
+      },
+    }
+
+    const factory = SDK_FACTORIES[model.api.npm]
+    if (!factory) {
+      throw new InitError(
+        { providerID: provider.id },
+        {
+          cause: new Error(
+            "Unsupported provider in ACP VM build: " + provider.id + " (" + model.api.npm + ")",
+          ),
+        },
+      )
+    }
+
+    const sdk = factory(options)
+
+    providerCache.set(cacheKey, sdk)
+    return sdk
+  }
+
+  export async function getLanguage(model: Model) {
+    const key = modelKey(model.providerID, model.id)
+    const cached = languageCache.get(key)
+    if (cached) return cached
+
+    try {
+      const provider = await getProvider(model.providerID)
+      const sdk = await getSdk(provider, model)
+      const language =
+        model.providerID === ProviderID.openai && typeof sdk.responses === "function"
+          ? sdk.responses(model.api.id)
+          : sdk.languageModel(model.api.id)
+      languageCache.set(key, language)
+      return language
+    } catch (cause) {
+      throw new InitError({ providerID: model.providerID }, { cause })
+    }
+  }
+
+  export async function closest(providerID: ProviderID, query: string[]) {
+    const provider = await getProvider(providerID).catch(() => undefined)
+    if (!provider) return undefined
+    for (const item of query) {
+      const match = Object.keys(provider.models).find((modelID) => modelID.includes(item))
+      if (match) return { providerID, modelID: ModelID.make(match) }
+    }
+    return undefined
+  }
+
+  export async function getSmallModel(providerID: ProviderID) {
+    const provider = await getProvider(providerID).catch(() => undefined)
+    if (!provider) return undefined
+
+    const preferred =
+      providerID === ProviderID.anthropic
+        ? ["haiku", "mini", "nano"]
+        : ["mini", "nano", "haiku"]
+
+    for (const token of preferred) {
+      const match = Object.values(provider.models).find((model) => model.id.includes(token))
+      if (match) return match
+    }
+
+    return undefined
+  }
+
+  export async function defaultModel() {
+    const cfg = await Config.get()
+    if (cfg.model) {
+      const parsed = parseModel(cfg.model)
+      const model = await getModel(parsed.providerID, parsed.modelID).catch(() => undefined)
+      if (model) {
+        return {
+          providerID: parsed.providerID,
+          modelID: parsed.modelID,
+        }
+      }
+    }
+
+    const providers = await loadProviders()
+    for (const provider of Object.values(providers)) {
+      const [model] = sort(Object.values(provider.models))
+      if (model) {
+        return {
+          providerID: provider.id,
+          modelID: model.id,
+        }
+      }
+    }
+
+    return {
+      providerID: ProviderID.anthropic,
+      modelID: ModelID.make("claude-sonnet-4-20250514"),
+    }
+  }
+
+  export function sort<T extends { id: string }>(models: T[]) {
+    return [...models].sort((a, b) => {
+      const aPriority = priority.findIndex((item) => a.id.includes(item))
+      const bPriority = priority.findIndex((item) => b.id.includes(item))
+      const aRank = aPriority === -1 ? Number.MAX_SAFE_INTEGER : aPriority
+      const bRank = bPriority === -1 ? Number.MAX_SAFE_INTEGER : bPriority
+      if (aRank !== bRank) return aRank - bRank
+
+      const aLatest = a.id.includes("latest") ? 1 : 0
+      const bLatest = b.id.includes("latest") ? 1 : 0
+      if (aLatest !== bLatest) return aLatest - bLatest
+
+      return a.id.localeCompare(b.id)
+    })
+  }
+
+  export function parseModel(model: string) {
+    const [providerID, ...rest] = model.split("/")
+    return {
+      providerID: ProviderID.make(providerID),
+      modelID: ModelID.make(rest.join("/")),
+    }
+  }
+
+  export const ModelNotFoundError = NamedError.create(
+    "ProviderModelNotFoundError",
+    z.object({
+      providerID: ProviderID.zod,
+      modelID: ModelID.zod,
+      suggestions: z.array(z.string()).optional(),
+    }),
+  )
+
+  export const InitError = NamedError.create(
+    "ProviderInitError",
+    z.object({
+      providerID: ProviderID.zod,
+    }),
+  )
+}
+`,
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/plugin/index.ts"),
+		`import { Effect, Layer, ServiceMap } from "effect"
+
+export namespace Plugin {
+  export interface Interface {
+    readonly trigger: <Name extends string, Input, Output>(
+      name: Name,
+      input: Input,
+      output: Output,
+    ) => Effect.Effect<Output>
+    readonly list: () => Effect.Effect<any[]>
+    readonly init: () => Effect.Effect<void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+
+  const noop = Service.of({
+    trigger: <Name extends string, Input, Output>(_name: Name, _input: Input, output: Output) =>
+      Effect.succeed(output),
+    list: () => Effect.succeed([]),
+    init: () => Effect.void,
+  })
+
+  export const layer = Layer.succeed(Service, noop)
+  export const defaultLayer = layer
+
+  export async function trigger<Name extends string, Input, Output>(
+    _name: Name,
+    _input: Input,
+    output: Output,
+  ): Promise<Output> {
+    return output
+  }
+
+  export async function list(): Promise<any[]> {
+    return []
+  }
+
+  export async function init(): Promise<void> {}
+}
+`,
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/project/bootstrap.ts"),
+		`import { Instance } from "./instance"
+import { Log } from "@/util/log"
+
+export async function InstanceBootstrap() {
+  Log.Default.info("bootstrapping", { directory: Instance.directory })
+  Log.Default.info("bootstrap step", { step: "minimal:init" })
+}
+`,
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/project/instance.ts",
+		(contents) =>
+			contents
+				.replace(
+					`function boot(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
+  return iife(async () => {
+`,
+					`function boot(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
+  return iife(async () => {
+    Log.Default.info("instance boot:start", { directory: input.directory })
+`,
+				)
+				.replace(
+					`    await context.provide(ctx, async () => {
+      await input.init?.()
+    })
+    return ctx
+`,
+					`    Log.Default.info("instance boot:ctx", {
+      directory: ctx.directory,
+      worktree: ctx.worktree,
+      projectID: ctx.project.id,
+    })
+    await context.provide(ctx, async () => {
+      Log.Default.info("instance boot:init:start", { directory: ctx.directory })
+      await input.init?.()
+      Log.Default.info("instance boot:init:done", { directory: ctx.directory })
+    })
+    Log.Default.info("instance boot:done", { directory: ctx.directory })
+    return ctx
+`,
+				)
+				.replace(
+					`    const ctx = await existing
+    return context.provide(ctx, async () => {
+      return input.fn()
+    })
+`,
+					`    Log.Default.info("instance provide:await:start", { directory })
+    const ctx = await existing
+    Log.Default.info("instance provide:await:done", { directory })
+    return context.provide(ctx, async () => {
+      Log.Default.info("instance provide:fn:start", { directory })
+      const result = await input.fn()
+      Log.Default.info("instance provide:fn:done", { directory })
+      return result
+    })
+`,
+				),
+	);
+
+	await rewriteSourceFile(
+		sourceRoot,
+		"packages/opencode/src/project/project.ts",
+		(contents) =>
+			contents.includes('log.info("phase2 select project"')
+				? contents
+				: contents
+				.replace(
+					`        // Phase 2: upsert
+        const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, data.id)).get())
+`,
+					`        // Phase 2: upsert
+        log.info("phase2 select project", { projectID: data.id })
+        const row = yield* db((d) => d.select().from(ProjectTable).where(eq(ProjectTable.id, data.id)).get())
+        log.info("phase2 select project done", { projectID: data.id, found: !!row })
+`,
+				)
+				.replace(
+					`        yield* db((d) =>
+          d
+            .insert(ProjectTable)
+            .values({
+`,
+					`        log.info("phase2 upsert project", {
+          projectID: result.id,
+          sandboxes: result.sandboxes.length,
+        })
+        yield* db((d) =>
+          d
+            .insert(ProjectTable)
+            .values({
+`,
+				)
+				.replace(
+					`        if (data.id !== ProjectID.global) {
+`,
+					`        log.info("phase2 upsert project done", { projectID: result.id })
+        if (data.id !== ProjectID.global) {
+`,
+				),
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/share/share-next.ts"),
+		`export namespace ShareNext {
+  const EMPTY_API = {
+    create: "",
+    sync: () => "",
+    remove: () => "",
+    data: () => "",
+  }
+
+  export async function url() {
+    return ""
+  }
+
+  export async function request() {
+    return {
+      headers: {},
+      api: EMPTY_API,
+      baseUrl: "",
+    }
+  }
+
+  export async function init() {}
+
+  export async function create(_sessionID: string) {
+    return { id: "", url: "", secret: "" }
+  }
+
+  export async function remove(_sessionID: string) {}
+}
+`,
+	);
+
+	await writeFile(
+		resolve(sourceRoot, "packages/opencode/src/cli/cmd/tui/win32.ts"),
+		`export function win32DisableProcessedInput() {}
+export function win32FlushInputBuffer() {}
+export function win32InstallCtrlCGuard() {
+  return
+}
+`,
+	);
+}
+
+function patchBuiltBundle(bundlePath) {
+	const original = readFileSync(bundlePath, "utf-8");
+	if (
+		original.includes(
+			"bash tool command scan failed, falling back to raw permission request",
+		)
+	) {
+		return;
+	}
+
+	const updated = original.replace(
+		`      async execute(params, ctx) {
+        const cwd = params.workdir ? await resolvePath(params.workdir, Instance.directory, shell2) : Instance.directory;
+        if (params.timeout !== undefined && params.timeout < 0) {
+          throw new Error(\`Invalid timeout value: \${params.timeout}. Timeout must be a positive number.\`);
+        }
+        const timeout4 = params.timeout ?? DEFAULT_TIMEOUT;
+        const ps2 = PS.has(name21);
+        const root = await parse10(params.command, ps2);
+        const scan5 = await collect6(root, cwd, ps2, shell2);
+        if (!Instance.containsPath(cwd))
+          scan5.dirs.add(cwd);
+        await ask(ctx, scan5);
+        return run7({
+`,
+		`      async execute(params, ctx) {
+        const cwd = params.workdir ? await resolvePath(params.workdir, Instance.directory, shell2) : Instance.directory;
+        if (params.timeout !== undefined && params.timeout < 0) {
+          throw new Error(\`Invalid timeout value: \${params.timeout}. Timeout must be a positive number.\`);
+        }
+        const timeout4 = params.timeout ?? DEFAULT_TIMEOUT;
+        const ps2 = PS.has(name21);
+        let scan5;
+        try {
+          const root = await parse10(params.command, ps2);
+          scan5 = await collect6(root, cwd, ps2, shell2);
+        } catch (error48) {
+          log7.warn("bash tool command scan failed, falling back to raw permission request", {
+            command: params.command,
+            error: error48 instanceof Error ? error48.message : String(error48)
+          });
+          scan5 = {
+            dirs: new Set,
+            patterns: new Set([params.command]),
+            always: new Set([params.command])
+          };
+        }
+        if (!Instance.containsPath(cwd))
+          scan5.dirs.add(cwd);
+        await ask(ctx, scan5);
+        return run7({
+`,
+	);
+
+	if (updated === original) {
+		throw new Error(
+			"Failed to patch built OpenCode ACP bundle for bash scan fallback",
+		);
+	}
+
+	writeFileSync(bundlePath, updated);
+}
+
+async function assertPreparedSource(sourceRoot) {
+	const instanceSource = await readFile(
+		resolve(sourceRoot, "packages/opencode/src/server/instance.ts"),
+		"utf8",
+	);
+	if (
+		instanceSource.includes('import { PtyRoutes } from "./routes/pty"') ||
+		instanceSource.includes('import { TuiRoutes } from "./routes/tui"') ||
+		instanceSource.includes('.route("/pty", PtyRoutes())') ||
+		instanceSource.includes('.route("/tui", TuiRoutes())')
+	) {
+		throw new Error("Prepared OpenCode source still exposes PTY/TUI routes in the ACP build");
+	}
+
+	const shellSource = await readFile(
+		resolve(sourceRoot, "packages/opencode/src/shell/shell.ts"),
+		"utf8",
+	);
+	if (shellSource.includes("Bun.which(")) {
+		throw new Error("Prepared OpenCode source still references Bun.which in shell.ts");
+	}
+
+	const win32Source = await readFile(
+		resolve(sourceRoot, "packages/opencode/src/cli/cmd/tui/win32.ts"),
+		"utf8",
+	);
+	if (win32Source.includes("bun:ffi")) {
+		throw new Error("Prepared OpenCode source still references bun:ffi in the Win32 TUI shim");
+	}
+
+	const dbNodeSource = await readFile(
+		resolve(sourceRoot, "packages/opencode/src/storage/db.node.ts"),
+		"utf8",
+	);
+	if (
+		!dbNodeSource.includes('from "drizzle-orm/node-sqlite"') ||
+		!dbNodeSource.includes('from "node:sqlite"')
+	) {
+		throw new Error("Prepared OpenCode source does not use the native node:sqlite database path");
+	}
+}
+
+async function assertBundleClean(bundlePath) {
+	const bundle = await readFile(bundlePath, "utf8");
+	for (const pattern of [
+		"bun:ffi",
+		"bun-pty",
+		"hono/bun",
+		'.route("/pty", PtyRoutes())',
+		'.route("/tui", TuiRoutes())',
+		"Bun.which(",
+		"bun:sqlite",
+	]) {
+		if (bundle.includes(pattern)) {
+			throw new Error(
+				`OpenCode ACP bundle still contains forbidden runtime dependency: ${pattern}`,
+			);
+		}
+	}
+}
+
+async function main() {
+	if (!existsSync(bunBin)) {
+		throw new Error(
+			`bun is not installed for @agentos-software/opencode (expected ${bunBin}). Run pnpm install first.`,
+		);
+	}
+
+	mkdirSync(distDir, { recursive: true });
+	mkdirSync(cacheDir, { recursive: true });
+	rmSync(bundleDir, { recursive: true, force: true });
+
+	const patch = readFileSync(patchPath, "utf-8");
+	const buildScript = readFileSync(fileURLToPath(import.meta.url), "utf-8");
+	const patchHash = createHash("sha256")
+		.update(`${SOURCE_VERSION}\n${patch}\n${buildScript}`)
+		.digest("hex")
+		.slice(0, 16);
+	const sourceRoot = join(cacheDir, `source-v${SOURCE_VERSION}-${patchHash}`);
+	const preparedMarker = join(sourceRoot, ".agentos-prepared.json");
+	const tarballPath = join(cacheDir, `opencode-v${SOURCE_VERSION}.tar.gz`);
+
+	if (!existsSync(preparedMarker)) {
+		rmSync(sourceRoot, { recursive: true, force: true });
+		mkdirSync(sourceRoot, { recursive: true });
+
+		if (!existsSync(tarballPath)) {
+			process.stdout.write(`Downloading OpenCode v${SOURCE_VERSION} source...\n`);
+			await downloadFile(SOURCE_TARBALL_URL, tarballPath);
+		}
+
+		run("tar", ["-xzf", tarballPath, "--strip-components=1", "-C", sourceRoot]);
+		pinGhosttyWebRef(sourceRoot);
+		run(bunBin, ["install", "--frozen-lockfile"], { cwd: sourceRoot });
+		await ensureNodeAcpPatch(sourceRoot, tarballPath);
+		await applyNodeAcpRuntimeTweaks(sourceRoot);
+		await assertPreparedSource(sourceRoot);
+
+		writeFileSync(
+			preparedMarker,
+			JSON.stringify(
+				{
+					sourceVersion: SOURCE_VERSION,
+					sourceRepository: SOURCE_REPOSITORY,
+					patchHash,
+				},
+				null,
+				2,
+				) + "\n",
+		);
+	}
+
+	await ensureNodeAcpPatch(sourceRoot, tarballPath);
+	await applyNodeAcpRuntimeTweaks(sourceRoot);
+	await assertPreparedSource(sourceRoot);
+
+	const migrations = await readMigrations(sourceRoot);
+	const buildHelperDir = await mkdtemp(join(tmpdir(), "agentos-opencode-build-"));
+	const buildHelperPath = join(buildHelperDir, "build-opencode-acp.mjs");
+	const bunVersion =
+		spawnSync(bunBin, ["--version"], { encoding: "utf-8" }).stdout?.trim() ??
+		"unknown";
+
+	try {
+		await writeFile(
+			buildHelperPath,
+			`
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+const outdir = process.env.OUTDIR;
+if (!outdir) {
+	throw new Error("OUTDIR is required");
+}
+
+const result = await Bun.build({
+	target: "node",
+	format: "esm",
+	outdir,
+	entrypoints: ["./packages/opencode/src/cli/cmd/acp.ts"],
+	define: {
+		OPENCODE_MIGRATIONS: ${JSON.stringify(JSON.stringify(migrations))},
+		OPENCODE_LIBC: ${JSON.stringify(JSON.stringify("glibc"))},
+	},
+});
+if (!result.success) {
+	for (const log of result.logs) {
+		console.error(log);
+	}
+	throw new Error("OpenCode ACP bundle build failed");
+}
+for (const output of result.outputs) {
+	const filePath = join(outdir, output.path);
+	await mkdir(dirname(filePath), { recursive: true });
+	await Bun.write(filePath, output);
+}
+`,
+		);
+
+		run(bunBin, [buildHelperPath], {
+			cwd: sourceRoot,
+			env: {
+				...process.env,
+				OUTDIR: bundleDir,
+			},
+		});
+	} finally {
+		rmSync(buildHelperDir, { recursive: true, force: true });
+	}
+
+	await assertBundleClean(join(bundleDir, "acp.js"));
+	patchBuiltBundle(join(bundleDir, "acp.js"));
+
+	writeFileSync(
+		manifestPath,
+		JSON.stringify(
+			{
+				source: {
+					repository: SOURCE_REPOSITORY,
+					version: SOURCE_VERSION,
+					tarballUrl: SOURCE_TARBALL_URL,
+				},
+				build: {
+					bunVersion,
+					patchHash,
+					externalDependencies: [],
+					entry: "./opencode-acp/acp.js",
+				},
+			},
+			null,
+			2,
+		) + "\n",
+	);
+}
+
+void main().catch((error) => {
+	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+	process.exitCode = 1;
+});