rm

gitlab integration poc
Merge branch 'dev' into add-model-reconciliation
2026-03-19 05:04:33 +00:00 · 2026-03-19 00:00:02 -05:00 · 2026-03-18 23:59:50 -05:00 · 2026-03-18 21:58:45 -05:00 · 2026-03-18 20:36:53 -04:00 · 2026-03-18 20:28:41 -04:00
31 changed files with 879 additions and 229 deletions
--- a/bun.lock
+++ b/bun.lock
@@ -46,7 +46,7 @@
        "@solidjs/router": "catalog:",
        "@thisbeyond/solid-dnd": "0.7.5",
        "diff": "catalog:",
-        "effect": "4.0.0-beta.31",
+        "effect": "catalog:",
        "fuzzysort": "catalog:",
        "ghostty-web": "github:anomalyco/ghostty-web#main",
        "luxon": "catalog:",
@@ -227,7 +227,7 @@
        "@solid-primitives/storage": "catalog:",
        "@solidjs/meta": "catalog:",
        "@solidjs/router": "0.15.4",
-        "effect": "4.0.0-beta.31",
+        "effect": "catalog:",
        "electron-log": "^5",
        "electron-store": "^10",
        "electron-updater": "^6",
@@ -324,8 +324,7 @@
        "@ai-sdk/xai": "2.0.51",
        "@aws-sdk/credential-providers": "3.993.0",
        "@clack/prompts": "1.0.0-alpha.1",
-        "@effect/platform-node": "4.0.0-beta.31",
-        "@gitlab/gitlab-ai-provider": "3.6.0",
+        "@effect/platform-node": "catalog:",
        "@gitlab/opencode-gitlab-auth": "1.3.3",
        "@hono/standard-validator": "0.1.5",
        "@hono/zod-validator": "catalog:",
@@ -358,6 +357,7 @@
        "drizzle-orm": "1.0.0-beta.16-ea816b6",
        "effect": "catalog:",
        "fuzzysort": "3.1.0",
+        "gitlab-ai-provider": "5.2.0",
        "glob": "13.0.5",
        "google-auth-library": "10.5.0",
        "gray-matter": "4.0.3",
@@ -594,6 +594,7 @@
  },
  "catalog": {
    "@cloudflare/workers-types": "4.20251008.0",
+    "@effect/platform-node": "4.0.0-beta.35",
    "@hono/zod-validator": "0.4.2",
    "@kobalte/core": "0.13.11",
    "@octokit/rest": "22.0.0",
@@ -617,7 +618,7 @@
    "dompurify": "3.3.1",
    "drizzle-kit": "1.0.0-beta.16-ea816b6",
    "drizzle-orm": "1.0.0-beta.16-ea816b6",
-    "effect": "4.0.0-beta.31",
+    "effect": "4.0.0-beta.35",
    "fuzzysort": "3.1.0",
    "hono": "4.10.7",
    "hono-openapi": "1.1.2",
@@ -975,9 +976,9 @@

    "@effect/language-service": ["@effect/language-service@0.79.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-DEmIOsg1GjjP6s9HXH1oJrW+gDmzkhVv9WOZl6to5eNyyCrjz1S2PDqQ7aYrW/HuifhfwI5Bik1pK4pj7Z+lrg=="],

-    "@effect/platform-node": ["@effect/platform-node@4.0.0-beta.31", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.31", "mime": "^4.1.0", "undici": "^7.20.0" }, "peerDependencies": { "effect": "^4.0.0-beta.31", "ioredis": "^5.7.0" } }, "sha512-KmVZwGsQRBMZZYPJwpL2vj6sxjBzfXhyA8RgsH5/cmckDTsZpVTyqODQ/FFzmCnMWuYjZoJGPghTDrVVDn/6ZA=="],
+    "@effect/platform-node": ["@effect/platform-node@4.0.0-beta.35", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.35", "mime": "^4.1.0", "undici": "^7.24.0" }, "peerDependencies": { "effect": "^4.0.0-beta.35", "ioredis": "^5.7.0" } }, "sha512-HPc2xZASl9F9y/xJ01bQgFD6Jf9XP4Fcv/BlVTvG0Yr/uN63lwKZYr/VXor5K5krHfBDeCBD8y7/SICPYZoq3A=="],

-    "@effect/platform-node-shared": ["@effect/platform-node-shared@4.0.0-beta.33", "", { "dependencies": { "@types/ws": "^8.18.1", "ws": "^8.19.0" }, "peerDependencies": { "effect": "^4.0.0-beta.33" } }, "sha512-jaJnvYz1IiPZyN//fCJsvwnmujJS5KD8noCVVLhb4ZGCWKhQpt0x2iuax6HFzMlPEQSfl04GLU+PVKh0nkzPyA=="],
+    "@effect/platform-node-shared": ["@effect/platform-node-shared@4.0.0-beta.35", "", { "dependencies": { "@types/ws": "^8.18.1", "ws": "^8.19.0" }, "peerDependencies": { "effect": "^4.0.0-beta.35" } }, "sha512-9bPqNV988itKJ7MQoJuzmR014DB9EZRDOnhJt/+iJlb8qLoR9HnCzNJb9gfBdYhFmVYc8DMsQxG81rdJzpv9tg=="],

    "@electron/asar": ["@electron/asar@3.4.1", "", { "dependencies": { "commander": "^5.0.0", "glob": "^7.1.6", "minimatch": "^3.0.4" }, "bin": { "asar": "bin/asar.js" } }, "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA=="],

@@ -1107,8 +1108,6 @@

    "@fontsource/inter": ["@fontsource/inter@5.2.8", "", {}, "sha512-P6r5WnJoKiNVV+zvW2xM13gNdFhAEpQ9dQJHt3naLvfg+LkF2ldgSLiF4T41lf1SQCM9QmkqPTn4TH568IRagg=="],

-    "@gitlab/gitlab-ai-provider": ["@gitlab/gitlab-ai-provider@3.6.0", "", { "dependencies": { "@anthropic-ai/sdk": "^0.71.0", "@anycable/core": "^0.9.2", "graphql-request": "^6.1.0", "isomorphic-ws": "^5.0.0", "openai": "^6.16.0", "socket.io-client": "^4.8.1", "vscode-jsonrpc": "^8.2.1", "zod": "^3.25.76" }, "peerDependencies": { "@ai-sdk/provider": ">=2.0.0", "@ai-sdk/provider-utils": ">=3.0.0" } }, "sha512-8LmcIQ86xkMtC7L4P1/QYVEC+yKMTRerfPeniaaQGalnzXKtX6iMHLjLPOL9Rxp55lOXi6ed0WrFuJzZx+fNRg=="],
-
    "@gitlab/opencode-gitlab-auth": ["@gitlab/opencode-gitlab-auth@1.3.3", "", { "dependencies": { "@fastify/rate-limit": "^10.2.0", "@opencode-ai/plugin": "*", "fastify": "^5.2.0", "open": "^10.0.0" } }, "sha512-FT+KsCmAJjtqWr1YAq0MywGgL9kaLQ4apmsoowAXrPqHtoYf2i/nY10/A+L06kNj22EATeEDRpbB1NWXMto/SA=="],

    "@graphql-typed-document-node/core": ["@graphql-typed-document-node/core@3.2.0", "", { "peerDependencies": { "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0" } }, "sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ=="],
@@ -2751,7 +2750,7 @@

    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],

-    "effect": ["effect@4.0.0-beta.31", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.5.3", "find-my-way-ts": "^0.1.6", "ini": "^6.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^1.11.8", "multipasta": "^0.2.7", "toml": "^3.0.0", "uuid": "^13.0.0", "yaml": "^2.8.2" } }, "sha512-w3QwJnlaLtWWiUSzhCXUTIisnULPsxLzpO6uqaBFjXybKx6FvCqsLJT6v4dV7G9eA9jeTtG6Gv7kF+jGe3HxzA=="],
+    "effect": ["effect@4.0.0-beta.35", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.5.3", "find-my-way-ts": "^0.1.6", "ini": "^6.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^1.11.8", "multipasta": "^0.2.7", "toml": "^3.0.0", "uuid": "^13.0.0", "yaml": "^2.8.2" } }, "sha512-64j8dgJmoEMeq6Y3WLYcZIRqPZ5E/lqnULCf6QW5te3hQ/sa13UodWLGwBEviEqBoq72U8lArhVX+T7ntzhJGQ=="],

    "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": { "ejs": "bin/cli.js" } }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="],

@@ -3027,6 +3026,8 @@

    "github-slugger": ["github-slugger@2.0.0", "", {}, "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw=="],

+    "gitlab-ai-provider": ["gitlab-ai-provider@5.2.0", "", { "dependencies": { "@anthropic-ai/sdk": "^0.71.0", "@anycable/core": "^0.9.2", "graphql-request": "^6.1.0", "isomorphic-ws": "^5.0.0", "openai": "^6.16.0", "socket.io-client": "^4.8.1", "vscode-jsonrpc": "^8.2.1", "zod": "^3.25.76" }, "peerDependencies": { "@ai-sdk/provider": ">=2.0.0", "@ai-sdk/provider-utils": ">=3.0.0" } }, "sha512-7uUbITj7tqNF+AG4AgVEYpkIsXGCCt0BLHULghaXktyP7DOqqMYc3967AnbYZQW04uC8MXeAxCCaaWZ/frwk3A=="],
+
    "glob": ["glob@13.0.5", "", { "dependencies": { "minimatch": "^10.2.1", "minipass": "^7.1.2", "path-scurry": "^2.0.0" } }, "sha512-BzXxZg24Ibra1pbQ/zE7Kys4Ua1ks7Bn6pKLkVPZ9FZe4JQS6/Q7ef3LG1H+k7lUf5l4T3PLSyYyYJVYUvfgTw=="],

    "glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
@@ -5019,6 +5020,8 @@

    "@dot/log/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],

+    "@effect/platform-node/undici": ["undici@7.24.4", "", {}, "sha512-BM/JzwwaRXxrLdElV2Uo6cTLEjhSb3WXboncJamZ15NgUURmvlXvxa6xkwIOILIjPNo9i8ku136ZvWV0Uly8+w=="],
+
    "@effect/platform-node-shared/ws": ["ws@8.19.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg=="],

    "@electron/asar/commander": ["commander@5.1.0", "", {}, "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="],
@@ -5051,10 +5054,6 @@

    "@fastify/proxy-addr/ipaddr.js": ["ipaddr.js@2.3.0", "", {}, "sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg=="],

-    "@gitlab/gitlab-ai-provider/openai": ["openai@6.27.0", "", { "peerDependencies": { "ws": "^8.18.0", "zod": "^3.25 || ^4.0" }, "optionalPeers": ["ws", "zod"], "bin": { "openai": "bin/cli" } }, "sha512-osTKySlrdYrLYTt0zjhY8yp0JUBmWDCN+Q+QxsV4xMQnnoVFpylgKGgxwN8sSdTNw0G4y+WUXs4eCMWpyDNWZQ=="],
-
-    "@gitlab/gitlab-ai-provider/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
-
    "@hey-api/openapi-ts/open": ["open@11.0.0", "", { "dependencies": { "default-browser": "^5.4.0", "define-lazy-prop": "^3.0.0", "is-in-ssh": "^1.0.0", "is-inside-container": "^1.0.0", "powershell-utils": "^0.1.0", "wsl-utils": "^0.3.0" } }, "sha512-smsWv2LzFjP03xmvFoJ331ss6h+jixfA4UUV/Bsiyuu4YJPfN+FIQGOIiv4w9/+MoHkfkJ22UIaQWRVFRfH6Vw=="],

    "@hey-api/openapi-ts/semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
@@ -5449,6 +5448,10 @@

    "gaxios/node-fetch": ["node-fetch@3.3.2", "", { "dependencies": { "data-uri-to-buffer": "^4.0.0", "fetch-blob": "^3.1.4", "formdata-polyfill": "^4.0.10" } }, "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA=="],

+    "gitlab-ai-provider/openai": ["openai@6.27.0", "", { "peerDependencies": { "ws": "^8.18.0", "zod": "^3.25 || ^4.0" }, "optionalPeers": ["ws", "zod"], "bin": { "openai": "bin/cli" } }, "sha512-osTKySlrdYrLYTt0zjhY8yp0JUBmWDCN+Q+QxsV4xMQnnoVFpylgKGgxwN8sSdTNw0G4y+WUXs4eCMWpyDNWZQ=="],
+
+    "gitlab-ai-provider/zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+
    "glob/minimatch": ["minimatch@10.2.4", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg=="],

    "globby/ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
--- a/package.json
+++ b/package.json
@@ -25,6 +25,7 @@
      "packages/slack"
    ],
    "catalog": {
+      "@effect/platform-node": "4.0.0-beta.35",
      "@types/bun": "1.3.9",
      "@octokit/rest": "22.0.0",
      "@hono/zod-validator": "0.4.2",
@@ -44,7 +45,7 @@
      "dompurify": "3.3.1",
      "drizzle-kit": "1.0.0-beta.16-ea816b6",
      "drizzle-orm": "1.0.0-beta.16-ea816b6",
-      "effect": "4.0.0-beta.31",
+      "effect": "4.0.0-beta.35",
      "ai": "5.0.124",
      "hono": "4.10.7",
      "hono-openapi": "1.1.2",
--- a/packages/app/e2e/prompt/prompt-multiline.spec.ts
+++ b/packages/app/e2e/prompt/prompt-multiline.spec.ts
@@ -7,12 +7,18 @@ test("shift+enter inserts a newline without submitting", async ({ page, gotoSess
  await expect(page).toHaveURL(/\/session\/?$/)

  const prompt = page.locator(promptSelector)
-  await prompt.click()
-  await page.keyboard.type("line one")
-  await page.keyboard.press("Shift+Enter")
-  await page.keyboard.type("line two")
+  await prompt.focus()
+  await expect(prompt).toBeFocused()
+
+  await prompt.pressSequentially("line one")
+  await expect(prompt).toBeFocused()
+
+  await prompt.press("Shift+Enter")
+  await expect(page).toHaveURL(/\/session\/?$/)
+  await expect(prompt).toBeFocused()
+
+  await prompt.pressSequentially("line two")

  await expect(page).toHaveURL(/\/session\/?$/)
-  await expect(prompt).toContainText("line one")
-  await expect(prompt).toContainText("line two")
+  await expect.poll(() => prompt.evaluate((el) => el.innerText)).toBe("line one\nline two")
 })
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -56,7 +56,7 @@
    "@solidjs/router": "catalog:",
    "@thisbeyond/solid-dnd": "0.7.5",
    "diff": "catalog:",
-    "effect": "4.0.0-beta.31",
+    "effect": "catalog:",
    "fuzzysort": "catalog:",
    "ghostty-web": "github:anomalyco/ghostty-web#main",
    "luxon": "catalog:",
--- a/packages/app/src/pages/layout.tsx
+++ b/packages/app/src/pages/layout.tsx
@@ -566,6 +566,7 @@ export default function Layout(props: ParentProps) {
  const [autoselecting] = createResource(async () => {
    await ready.promise
    await layout.ready.promise
+    if (!untrack(() => state.autoselect)) return

    const list = layout.projects.list()
    const last = server.projects.last()
--- a/packages/desktop-electron/package.json
+++ b/packages/desktop-electron/package.json
@@ -30,7 +30,7 @@
    "@solid-primitives/storage": "catalog:",
    "@solidjs/meta": "catalog:",
    "@solidjs/router": "0.15.4",
-    "effect": "4.0.0-beta.31",
+    "effect": "catalog:",
    "electron-log": "^5",
    "electron-store": "^10",
    "electron-updater": "^6",
--- a/packages/opencode/package.json
+++ b/packages/opencode/package.json
@@ -6,6 +6,7 @@
  "license": "MIT",
  "private": true,
  "scripts": {
+    "prepare": "effect-language-service patch || true",
    "typecheck": "tsgo --noEmit",
    "test": "bun test --timeout 30000",
    "build": "bun run script/build.ts",
@@ -81,8 +82,7 @@
    "@ai-sdk/xai": "2.0.51",
    "@aws-sdk/credential-providers": "3.993.0",
    "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "4.0.0-beta.31",
-    "@gitlab/gitlab-ai-provider": "3.6.0",
+    "gitlab-ai-provider": "5.2.0",
    "@gitlab/opencode-gitlab-auth": "1.3.3",
    "@hono/standard-validator": "0.1.5",
    "@hono/zod-validator": "catalog:",
@@ -97,6 +97,7 @@
    "@openrouter/ai-sdk-provider": "1.5.4",
    "@opentui/core": "0.1.87",
    "@opentui/solid": "0.1.87",
+    "@effect/platform-node": "catalog:",
    "@parcel/watcher": "2.5.1",
    "@pierre/diffs": "catalog:",
    "@solid-primitives/event-bus": "1.1.2",
--- a/packages/opencode/src/cli/cmd/models.ts
+++ b/packages/opencode/src/cli/cmd/models.ts
@@ -51,7 +51,7 @@ export const ModelsCommand = cmd({
        }

        if (args.provider) {
-          const provider = providers[args.provider]
+          const provider = providers[ProviderID.make(args.provider)]
          if (!provider) {
            UI.error(`Provider not found: ${args.provider}`)
            return
--- a/packages/opencode/src/file/watcher.ts
+++ b/packages/opencode/src/file/watcher.ts
@@ -51,6 +51,13 @@ export namespace FileWatcher {
    if (process.platform === "linux") return "inotify"
  }

+  function protecteds(dir: string) {
+    return Protected.paths().filter((item) => {
+      const rel = path.relative(dir, item)
+      return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel)
+    })
+  }
+
  export const hasNativeBinding = () => !!watcher()

  export class Service extends ServiceMap.Service<Service, {}>()("@opencode/FileWatcher") {}
@@ -105,7 +112,7 @@ export namespace FileWatcher {
      const cfgIgnores = cfg.watcher?.ignore ?? []

      if (yield* Flag.OPENCODE_EXPERIMENTAL_FILEWATCHER) {
-        yield* subscribe(instance.directory, [...FileIgnore.PATTERNS, ...cfgIgnores, ...Protected.paths()])
+        yield* subscribe(instance.directory, [...FileIgnore.PATTERNS, ...cfgIgnores, ...protecteds(instance.directory)])
      }

      if (instance.project.vcs === "git") {
--- a/packages/opencode/src/filesystem/index.ts
+++ b/packages/opencode/src/filesystem/index.ts
@@ -0,0 +1,197 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { dirname, join, relative, resolve as pathResolve } from "path"
+import { realpathSync } from "fs"
+import { lookup } from "mime-types"
+import { Effect, FileSystem, Layer, Schema, ServiceMap } from "effect"
+import type { PlatformError } from "effect/PlatformError"
+import { Glob } from "../util/glob"
+
+export namespace AppFileSystem {
+  export class FileSystemError extends Schema.TaggedErrorClass<FileSystemError>()("FileSystemError", {
+    method: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  export type Error = PlatformError | FileSystemError
+
+  export interface Interface extends FileSystem.FileSystem {
+    readonly isDir: (path: string) => Effect.Effect<boolean, Error>
+    readonly isFile: (path: string) => Effect.Effect<boolean, Error>
+    readonly readJson: (path: string) => Effect.Effect<unknown, Error>
+    readonly writeJson: (path: string, data: unknown, mode?: number) => Effect.Effect<void, Error>
+    readonly ensureDir: (path: string) => Effect.Effect<void, Error>
+    readonly writeWithDirs: (path: string, content: string | Uint8Array, mode?: number) => Effect.Effect<void, Error>
+    readonly findUp: (target: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly up: (options: { targets: string[]; start: string; stop?: string }) => Effect.Effect<string[], Error>
+    readonly globUp: (pattern: string, start: string, stop?: string) => Effect.Effect<string[], Error>
+    readonly glob: (pattern: string, options?: Glob.Options) => Effect.Effect<string[], Error>
+    readonly globMatch: (pattern: string, filepath: string) => boolean
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/FileSystem") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem
+
+      const isDir = Effect.fn("FileSystem.isDir")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "Directory"
+      })
+
+      const isFile = Effect.fn("FileSystem.isFile")(function* (path: string) {
+        const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.void))
+        return info?.type === "File"
+      })
+
+      const readJson = Effect.fn("FileSystem.readJson")(function* (path: string) {
+        const text = yield* fs.readFileString(path)
+        return JSON.parse(text)
+      })
+
+      const writeJson = Effect.fn("FileSystem.writeJson")(function* (path: string, data: unknown, mode?: number) {
+        const content = JSON.stringify(data, null, 2)
+        yield* fs.writeFileString(path, content)
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const ensureDir = Effect.fn("FileSystem.ensureDir")(function* (path: string) {
+        yield* fs.makeDirectory(path, { recursive: true })
+      })
+
+      const writeWithDirs = Effect.fn("FileSystem.writeWithDirs")(function* (
+        path: string,
+        content: string | Uint8Array,
+        mode?: number,
+      ) {
+        const write = typeof content === "string" ? fs.writeFileString(path, content) : fs.writeFile(path, content)
+
+        yield* write.pipe(
+          Effect.catchIf(
+            (e) => e.reason._tag === "NotFound",
+            () =>
+              Effect.gen(function* () {
+                yield* fs.makeDirectory(dirname(path), { recursive: true })
+                yield* write
+              }),
+          ),
+        )
+        if (mode) yield* fs.chmod(path, mode)
+      })
+
+      const glob = Effect.fn("FileSystem.glob")(function* (pattern: string, options?: Glob.Options) {
+        return yield* Effect.tryPromise({
+          try: () => Glob.scan(pattern, options),
+          catch: (cause) => new FileSystemError({ method: "glob", cause }),
+        })
+      })
+
+      const findUp = Effect.fn("FileSystem.findUp")(function* (target: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const search = join(current, target)
+          if (yield* fs.exists(search)) result.push(search)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const up = Effect.fn("FileSystem.up")(function* (options: { targets: string[]; start: string; stop?: string }) {
+        const result: string[] = []
+        let current = options.start
+        while (true) {
+          for (const target of options.targets) {
+            const search = join(current, target)
+            if (yield* fs.exists(search)) result.push(search)
+          }
+          if (options.stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      const globUp = Effect.fn("FileSystem.globUp")(function* (pattern: string, start: string, stop?: string) {
+        const result: string[] = []
+        let current = start
+        while (true) {
+          const matches = yield* glob(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
+            Effect.catch(() => Effect.succeed([] as string[])),
+          )
+          result.push(...matches)
+          if (stop === current) break
+          const parent = dirname(current)
+          if (parent === current) break
+          current = parent
+        }
+        return result
+      })
+
+      return Service.of({
+        ...fs,
+        isDir,
+        isFile,
+        readJson,
+        writeJson,
+        ensureDir,
+        writeWithDirs,
+        findUp,
+        up,
+        globUp,
+        glob,
+        globMatch: Glob.match,
+      })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer))
+
+  // Pure helpers that don't need Effect (path manipulation, sync operations)
+  export function mimeType(p: string): string {
+    return lookup(p) || "application/octet-stream"
+  }
+
+  export function normalizePath(p: string): string {
+    if (process.platform !== "win32") return p
+    try {
+      return realpathSync.native(p)
+    } catch {
+      return p
+    }
+  }
+
+  export function resolve(p: string): string {
+    const resolved = pathResolve(windowsPath(p))
+    try {
+      return normalizePath(realpathSync(resolved))
+    } catch (e: any) {
+      if (e?.code === "ENOENT") return normalizePath(resolved)
+      throw e
+    }
+  }
+
+  export function windowsPath(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()}:/`)
+  }
+
+  export function overlaps(a: string, b: string) {
+    const relA = relative(a, b)
+    const relB = relative(b, a)
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+  }
+
+  export function contains(parent: string, child: string) {
+    return !relative(parent, child).startsWith("..")
+  }
+}
--- a/packages/opencode/src/plugin/codex.ts
+++ b/packages/opencode/src/plugin/codex.ts
@@ -1,7 +1,7 @@
 import type { Hooks, PluginInput } from "@opencode-ai/plugin"
 import { Log } from "../util/log"
 import { Installation } from "../installation"
-import { Auth, OAUTH_DUMMY_KEY } from "../auth"
+import { OAUTH_DUMMY_KEY } from "../auth"
 import os from "os"
 import { ProviderTransform } from "@/provider/transform"
 import { ModelID, ProviderID } from "@/provider/schema"
--- a/packages/opencode/src/plugin/gitlab.ts
+++ b/packages/opencode/src/plugin/gitlab.ts
@@ -0,0 +1,86 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin"
+import { discoverWorkflowModels } from "gitlab-ai-provider"
+import { Log } from "@/util/log"
+import { ProviderTransform } from "@/provider/transform"
+import { ModelID, ProviderID } from "@/provider/schema"
+
+const log = Log.create({ service: "plugin.gitlab" })
+
+function str(value: unknown, fallback: string) {
+  if (typeof value === "string" && value) return value
+  return fallback
+}
+
+export async function GitlabPlugin(input: PluginInput): Promise<Hooks> {
+  return {
+    provider: {
+      id: "gitlab",
+      models: {
+        async reconcile(args) {
+          const url = str(args.options?.instanceUrl, "https://gitlab.com")
+
+          const token = str(args.options?.apiKey, "")
+          if (!token) return
+          const headers = (): Record<string, string> => {
+            if (args.auth?.type === "api") return { "PRIVATE-TOKEN": token }
+            return { Authorization: `Bearer ${token}` }
+          }
+
+          try {
+            log.info("gitlab model discovery starting", { instanceUrl: url })
+            const res = await discoverWorkflowModels(
+              { instanceUrl: url, getHeaders: headers },
+              { workingDirectory: input.directory },
+            )
+
+            if (!res.models.length) {
+              log.info("gitlab model discovery skipped: no models found", {
+                project: res.project ? { id: res.project.id, path: res.project.pathWithNamespace } : null,
+              })
+              return
+            }
+            for (const model of res.models) {
+              if (args.models[model.id]) {
+                continue
+              }
+
+              const m = {
+                id: ModelID.make(model.id),
+                providerID: ProviderID.make("gitlab"),
+                name: `Agent Platform (${model.name})`,
+                api: {
+                  id: model.id,
+                  url,
+                  npm: "gitlab-ai-provider",
+                },
+                status: "active" as const,
+                headers: {},
+                options: { workflowRef: model.ref },
+                cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+                limit: { context: model.context, output: model.output },
+                capabilities: {
+                  temperature: false,
+                  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,
+                },
+                release_date: "",
+                variants: {} as Record<string, Record<string, any>>,
+              }
+              m.variants = ProviderTransform.variants(m)
+              args.models[model.id] = m
+            }
+
+            return args.models
+          } catch (err) {
+            log.warn("gitlab model discovery failed", { error: err })
+            return
+          }
+        },
+      },
+    },
+  }
+}
--- a/packages/opencode/src/plugin/index.ts
+++ b/packages/opencode/src/plugin/index.ts
@@ -12,6 +12,7 @@ import { Session } from "../session"
 import { NamedError } from "@opencode-ai/util/error"
 import { CopilotAuthPlugin } from "./copilot"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "@gitlab/opencode-gitlab-auth"
+import { GitlabPlugin } from "./gitlab"

 export namespace Plugin {
  const log = Log.create({ service: "plugin" })
@@ -19,7 +20,7 @@ export namespace Plugin {
  const BUILTIN = ["opencode-anthropic-auth@0.0.13"]

  // Built-in plugins that are directly imported (not installed from npm)
-  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin]
+  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin, GitlabPlugin]

  const state = Instance.state(async () => {
    const client = createOpencodeClient({
@@ -110,9 +111,9 @@ export namespace Plugin {
  })

  export async function trigger<
-    Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool">,
-    Input = Parameters<Required<Hooks>[Name]>[0],
-    Output = Parameters<Required<Hooks>[Name]>[1],
+    Name extends Exclude<keyof Required<Hooks>, "auth" | "event" | "tool" | "provider">,
+    Input = Parameters<Extract<Required<Hooks>[Name], (...args: any) => any>>[0],
+    Output = Parameters<Extract<Required<Hooks>[Name], (...args: any) => any>>[1],
  >(name: Name, input: Input, output: Output): Promise<Output> {
    if (!name) return output
    for (const hook of await state().then((x) => x.hooks)) {
--- a/packages/opencode/src/provider/provider.ts
+++ b/packages/opencode/src/provider/provider.ts
@@ -839,7 +839,7 @@ export namespace Provider {
      return true
    }

-    const providers: { [providerID: string]: Info } = {}
+    const providers: Record<ProviderID, Info> = {} as Record<ProviderID, Info>
    const languages = new Map<string, LanguageModelV2>()
    const modelLoaders: {
      [providerID: string]: CustomModelLoader
--- a/packages/opencode/src/provider/schema.ts
+++ b/packages/opencode/src/provider/schema.ts
@@ -22,6 +22,7 @@ export const ProviderID = providerIdSchema.pipe(
    azure: schema.makeUnsafe("azure"),
    openrouter: schema.makeUnsafe("openrouter"),
    mistral: schema.makeUnsafe("mistral"),
+    gitlab: schema.makeUnsafe("gitlab"),
  })),
 )

--- a/packages/opencode/src/session/message-v2.ts
+++ b/packages/opencode/src/session/message-v2.ts
@@ -956,7 +956,7 @@ export namespace MessageV2 {
          { cause: e },
        ).toObject()
      case e instanceof Error:
-        return new NamedError.Unknown({ message: e.toString() }, { cause: e }).toObject()
+        return new NamedError.Unknown({ message: e instanceof Error ? e.message : String(e) }, { cause: e }).toObject()
      default:
        try {
          const parsed = ProviderError.parseStreamError(e)
--- a/packages/opencode/src/session/processor.ts
+++ b/packages/opencode/src/session/processor.ts
@@ -210,7 +210,7 @@ export namespace SessionProcessor {
                      state: {
                        status: "error",
                        input: value.input ?? match.state.input,
-                        error: (value.error as any).toString(),
+                        error: value.error instanceof Error ? value.error.message : String(value.error),
                        time: {
                          start: match.state.time.start,
                          end: Date.now(),
--- a/packages/opencode/src/skill/discovery.ts
+++ b/packages/opencode/src/skill/discovery.ts
@@ -1,7 +1,8 @@
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Effect, FileSystem, Layer, Path, Schema, ServiceMap } from "effect"
+import { NodePath } from "@effect/platform-node"
+import { Effect, Layer, Path, Schema, ServiceMap } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { withTransientReadRetry } from "@/util/effect-http-client"
+import { AppFileSystem } from "@/filesystem"
 import { Global } from "../global"
 import { Log } from "../util/log"

@@ -24,12 +25,12 @@ export namespace Discovery {

  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SkillDiscovery") {}

-  export const layer: Layer.Layer<Service, never, FileSystem.FileSystem | Path.Path | HttpClient.HttpClient> =
+  export const layer: Layer.Layer<Service, never, AppFileSystem.Service | Path.Path | HttpClient.HttpClient> =
    Layer.effect(
      Service,
      Effect.gen(function* () {
        const log = Log.create({ service: "skill-discovery" })
-        const fs = yield* FileSystem.FileSystem
+        const fs = yield* AppFileSystem.Service
        const path = yield* Path.Path
        const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
        const cache = path.join(Global.Path.cache, "skills")
@@ -40,11 +41,7 @@ export namespace Discovery {
          return yield* HttpClientRequest.get(url).pipe(
            http.execute,
            Effect.flatMap((res) => res.arrayBuffer),
-            Effect.flatMap((body) =>
-              fs
-                .makeDirectory(path.dirname(dest), { recursive: true })
-                .pipe(Effect.flatMap(() => fs.writeFile(dest, new Uint8Array(body)))),
-            ),
+            Effect.flatMap((body) => fs.writeWithDirs(dest, new Uint8Array(body))),
            Effect.as(true),
            Effect.catch((err) =>
              Effect.sync(() => {
@@ -113,7 +110,7 @@ export namespace Discovery {

  export const defaultLayer: Layer.Layer<Service> = layer.pipe(
    Layer.provide(FetchHttpClient.layer),
-    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(AppFileSystem.defaultLayer),
    Layer.provide(NodePath.layer),
  )
 }
--- a/packages/opencode/src/snapshot/index.ts
+++ b/packages/opencode/src/snapshot/index.ts
@@ -1,10 +1,11 @@
 import { NodeChildProcessSpawner, NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, FileSystem, Layer, Schedule, ServiceMap, Stream } from "effect"
+import { Cause, Duration, Effect, Layer, Schedule, ServiceMap, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import path from "path"
 import z from "zod"
 import { InstanceContext } from "@/effect/instance-context"
 import { runPromiseInstance } from "@/effect/runtime"
+import { AppFileSystem } from "@/filesystem"
 import { Config } from "../config/config"
 import { Global } from "../global"
 import { Log } from "../util/log"
@@ -85,12 +86,12 @@ export namespace Snapshot {
  export const layer: Layer.Layer<
    Service,
    never,
-    InstanceContext | FileSystem.FileSystem | ChildProcessSpawner.ChildProcessSpawner
+    InstanceContext | AppFileSystem.Service | ChildProcessSpawner.ChildProcessSpawner
  > = Layer.effect(
    Service,
    Effect.gen(function* () {
      const ctx = yield* InstanceContext
-      const fs = yield* FileSystem.FileSystem
+      const fs = yield* AppFileSystem.Service
      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
      const directory = ctx.directory
      const worktree = ctx.worktree
@@ -124,9 +125,8 @@ export namespace Snapshot {
        ),
      )

+      // Snapshot-specific error handling on top of AppFileSystem
      const exists = (file: string) => fs.exists(file).pipe(Effect.orDie)
-      const mkdir = (dir: string) => fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orDie)
-      const write = (file: string, text: string) => fs.writeFileString(file, text).pipe(Effect.orDie)
      const read = (file: string) => fs.readFileString(file).pipe(Effect.catch(() => Effect.succeed("")))
      const remove = (file: string) => fs.remove(file).pipe(Effect.catch(() => Effect.void))

@@ -148,12 +148,12 @@ export namespace Snapshot {
      const sync = Effect.fnUntraced(function* () {
        const file = yield* excludes()
        const target = path.join(gitdir, "info", "exclude")
-        yield* mkdir(path.join(gitdir, "info"))
+        yield* fs.ensureDir(path.join(gitdir, "info")).pipe(Effect.orDie)
        if (!file) {
-          yield* write(target, "")
+          yield* fs.writeFileString(target, "").pipe(Effect.orDie)
          return
        }
-        yield* write(target, yield* read(file))
+        yield* fs.writeFileString(target, yield* read(file)).pipe(Effect.orDie)
      })

      const add = Effect.fnUntraced(function* () {
@@ -178,7 +178,7 @@ export namespace Snapshot {
      const track = Effect.fn("Snapshot.track")(function* () {
        if (!(yield* enabled())) return
        const existed = yield* exists(gitdir)
-        yield* mkdir(gitdir)
+        yield* fs.ensureDir(gitdir).pipe(Effect.orDie)
        if (!existed) {
          yield* git(["init"], {
            env: { GIT_DIR: gitdir, GIT_WORK_TREE: worktree },
@@ -342,7 +342,8 @@ export namespace Snapshot {

  export const defaultLayer = layer.pipe(
    Layer.provide(NodeChildProcessSpawner.layer),
-    Layer.provide(NodeFileSystem.layer),
+    Layer.provide(AppFileSystem.defaultLayer),
+    Layer.provide(NodeFileSystem.layer), // needed by NodeChildProcessSpawner
    Layer.provide(NodePath.layer),
  )
 }
--- a/packages/opencode/src/tool/truncate-effect.ts
+++ b/packages/opencode/src/tool/truncate-effect.ts
@@ -1,7 +1,8 @@
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, FileSystem, Layer, Schedule, ServiceMap } from "effect"
+import { NodePath } from "@effect/platform-node"
+import { Cause, Duration, Effect, Layer, Schedule, ServiceMap } from "effect"
 import path from "path"
 import type { Agent } from "../agent/agent"
+import { AppFileSystem } from "@/filesystem"
 import { PermissionNext } from "../permission"
 import { Identifier } from "../id/id"
 import { Log } from "../util/log"
@@ -44,7 +45,7 @@ export namespace TruncateEffect {
  export const layer = Layer.effect(
    Service,
    Effect.gen(function* () {
-      const fs = yield* FileSystem.FileSystem
+      const fs = yield* AppFileSystem.Service

      const cleanup = Effect.fn("Truncate.cleanup")(function* () {
        const cutoff = Identifier.timestamp(Identifier.create("tool", false, Date.now() - Duration.toMillis(RETENTION)))
@@ -101,7 +102,7 @@ export namespace TruncateEffect {
        const preview = out.join("\n")
        const file = path.join(TRUNCATION_DIR, ToolID.ascending())

-        yield* fs.makeDirectory(TRUNCATION_DIR, { recursive: true }).pipe(Effect.orDie)
+        yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
        yield* fs.writeFileString(file, text).pipe(Effect.orDie)

        const hint = hasTaskTool(agent)
@@ -132,5 +133,5 @@ export namespace TruncateEffect {
    }),
  )

-  export const defaultLayer = layer.pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(NodePath.layer))
+  export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))
 }
--- a/packages/opencode/src/util/eventloop.ts
+++ b/packages/opencode/src/util/eventloop.ts
@@ -1,20 +0,0 @@
-import { Log } from "./log"
-
-export namespace EventLoop {
-  export async function wait() {
-    return new Promise<void>((resolve) => {
-      const check = () => {
-        const active = [...(process as any)._getActiveHandles(), ...(process as any)._getActiveRequests()]
-        Log.Default.info("eventloop", {
-          active,
-        })
-        if ((process as any)._getActiveHandles().length === 0 && (process as any)._getActiveRequests().length === 0) {
-          resolve()
-        } else {
-          setImmediate(check)
-        }
-      }
-      check()
-    })
-  }
-}
--- a/packages/opencode/src/util/process.ts
+++ b/packages/opencode/src/util/process.ts
@@ -98,6 +98,7 @@ export namespace Process {
        reject(error)
      })
    })
+    void exited.catch(() => undefined)

    if (opts.abort) {
      opts.abort.addEventListener("abort", abort, { once: true })
--- a/packages/opencode/test/file/watcher.test.ts
+++ b/packages/opencode/test/file/watcher.test.ts
@@ -2,7 +2,7 @@ import { $ } from "bun"
 import { afterEach, describe, expect, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
-import { Deferred, Effect, Fiber, Option } from "effect"
+import { Deferred, Effect, Option } from "effect"
 import { tmpdir } from "../fixture/fixture"
 import { watcherConfigLayer, withServices } from "../fixture/instance"
 import { FileWatcher } from "../../src/file/watcher"
@@ -25,6 +25,7 @@ function withWatcher<E>(directory: string, body: Effect.Effect<void, E>) {
    directory,
    FileWatcher.layer,
    async (rt) => {
+      await rt.runPromise(FileWatcher.Service.use(() => Effect.void))
      await Effect.runPromise(ready(directory))
      await Effect.runPromise(body)
    },
@@ -54,24 +55,29 @@ function listen(directory: string, check: (evt: WatcherEvent) => boolean, hit: (
 }

 function wait(directory: string, check: (evt: WatcherEvent) => boolean) {
-  return Effect.callback<WatcherEvent>((resume) => {
-    const cleanup = listen(directory, check, (evt) => {
-      cleanup()
-      resume(Effect.succeed(evt))
+  return Effect.gen(function* () {
+    const deferred = yield* Deferred.make<WatcherEvent>()
+    const cleanup = yield* Effect.sync(() => {
+      let off = () => {}
+      off = listen(directory, check, (evt) => {
+        off()
+        Deferred.doneUnsafe(deferred, Effect.succeed(evt))
+      })
+      return off
    })
-    return Effect.sync(cleanup)
-  }).pipe(Effect.timeout("5 seconds"))
+    return { cleanup, deferred }
+  })
 }

 function nextUpdate<E>(directory: string, check: (evt: WatcherEvent) => boolean, trigger: Effect.Effect<void, E>) {
  return Effect.acquireUseRelease(
-    wait(directory, check).pipe(Effect.forkChild({ startImmediately: true })),
-    (fiber) =>
+    wait(directory, check),
+    ({ deferred }) =>
      Effect.gen(function* () {
        yield* trigger
-        return yield* Fiber.join(fiber)
+        return yield* Deferred.await(deferred).pipe(Effect.timeout("5 seconds"))
      }),
-    Fiber.interrupt,
+    ({ cleanup }) => Effect.sync(cleanup),
  )
 }

@@ -82,23 +88,15 @@ function noUpdate<E>(
  trigger: Effect.Effect<void, E>,
  ms = 500,
 ) {
-  return Effect.gen(function* () {
-    const deferred = yield* Deferred.make<WatcherEvent>()
-
-    yield* Effect.acquireUseRelease(
-      Effect.sync(() =>
-        listen(directory, check, (evt) => {
-          Effect.runSync(Deferred.succeed(deferred, evt))
-        }),
-      ),
-      () =>
-        Effect.gen(function* () {
-          yield* trigger
-          expect(yield* Deferred.await(deferred).pipe(Effect.timeoutOption(`${ms} millis`))).toEqual(Option.none())
-        }),
-      (cleanup) => Effect.sync(cleanup),
-    )
-  })
+  return Effect.acquireUseRelease(
+    wait(directory, check),
+    ({ deferred }) =>
+      Effect.gen(function* () {
+        yield* trigger
+        expect(yield* Deferred.await(deferred).pipe(Effect.timeoutOption(`${ms} millis`))).toEqual(Option.none())
+      }),
+    ({ cleanup }) => Effect.sync(cleanup),
+  )
 }

 function ready(directory: string) {
--- a/packages/opencode/test/filesystem/filesystem.test.ts
+++ b/packages/opencode/test/filesystem/filesystem.test.ts
@@ -0,0 +1,319 @@
+import { describe, test, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { NodeFileSystem } from "@effect/platform-node"
+import { AppFileSystem } from "../../src/filesystem"
+import { testEffect } from "../lib/effect"
+import path from "path"
+
+const live = AppFileSystem.layer.pipe(Layer.provide(NodeFileSystem.layer))
+const { effect: it } = testEffect(live)
+
+describe("AppFileSystem", () => {
+  describe("isDir", () => {
+    it(
+      "returns true for directories",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        expect(yield* fs.isDir(tmp)).toBe(true)
+      }),
+    )
+
+    it(
+      "returns false for files",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "test.txt")
+        yield* fs.writeFileString(file, "hello")
+        expect(yield* fs.isDir(file)).toBe(false)
+      }),
+    )
+
+    it(
+      "returns false for non-existent paths",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        expect(yield* fs.isDir("/tmp/nonexistent-" + Math.random())).toBe(false)
+      }),
+    )
+  })
+
+  describe("isFile", () => {
+    it(
+      "returns true for files",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "test.txt")
+        yield* fs.writeFileString(file, "hello")
+        expect(yield* fs.isFile(file)).toBe(true)
+      }),
+    )
+
+    it(
+      "returns false for directories",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        expect(yield* fs.isFile(tmp)).toBe(false)
+      }),
+    )
+  })
+
+  describe("readJson / writeJson", () => {
+    it(
+      "round-trips JSON data",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "data.json")
+        const data = { name: "test", count: 42, nested: { ok: true } }
+
+        yield* fs.writeJson(file, data)
+        const result = yield* fs.readJson(file)
+
+        expect(result).toEqual(data)
+      }),
+    )
+  })
+
+  describe("ensureDir", () => {
+    it(
+      "creates nested directories",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const nested = path.join(tmp, "a", "b", "c")
+
+        yield* fs.ensureDir(nested)
+
+        const info = yield* fs.stat(nested)
+        expect(info.type).toBe("Directory")
+      }),
+    )
+
+    it(
+      "is idempotent",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const dir = path.join(tmp, "existing")
+        yield* fs.makeDirectory(dir)
+
+        yield* fs.ensureDir(dir)
+
+        const info = yield* fs.stat(dir)
+        expect(info.type).toBe("Directory")
+      }),
+    )
+  })
+
+  describe("writeWithDirs", () => {
+    it(
+      "creates parent directories if missing",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "deep", "nested", "file.txt")
+
+        yield* fs.writeWithDirs(file, "hello")
+
+        expect(yield* fs.readFileString(file)).toBe("hello")
+      }),
+    )
+
+    it(
+      "writes directly when parent exists",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "direct.txt")
+
+        yield* fs.writeWithDirs(file, "world")
+
+        expect(yield* fs.readFileString(file)).toBe("world")
+      }),
+    )
+
+    it(
+      "writes Uint8Array content",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "binary.bin")
+        const content = new Uint8Array([0x00, 0x01, 0x02, 0x03])
+
+        yield* fs.writeWithDirs(file, content)
+
+        const result = yield* fs.readFile(file)
+        expect(new Uint8Array(result)).toEqual(content)
+      }),
+    )
+  })
+
+  describe("findUp", () => {
+    it(
+      "finds target in start directory",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "target.txt"), "found")
+
+        const result = yield* fs.findUp("target.txt", tmp)
+        expect(result).toEqual([path.join(tmp, "target.txt")])
+      }),
+    )
+
+    it(
+      "finds target in parent directories",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "marker"), "root")
+        const child = path.join(tmp, "a", "b")
+        yield* fs.makeDirectory(child, { recursive: true })
+
+        const result = yield* fs.findUp("marker", child, tmp)
+        expect(result).toEqual([path.join(tmp, "marker")])
+      }),
+    )
+
+    it(
+      "returns empty array when not found",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const result = yield* fs.findUp("nonexistent", tmp, tmp)
+        expect(result).toEqual([])
+      }),
+    )
+  })
+
+  describe("up", () => {
+    it(
+      "finds multiple targets walking up",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "a.txt"), "a")
+        yield* fs.writeFileString(path.join(tmp, "b.txt"), "b")
+        const child = path.join(tmp, "sub")
+        yield* fs.makeDirectory(child)
+        yield* fs.writeFileString(path.join(child, "a.txt"), "a-child")
+
+        const result = yield* fs.up({ targets: ["a.txt", "b.txt"], start: child, stop: tmp })
+
+        expect(result).toContain(path.join(child, "a.txt"))
+        expect(result).toContain(path.join(tmp, "a.txt"))
+        expect(result).toContain(path.join(tmp, "b.txt"))
+      }),
+    )
+  })
+
+  describe("glob", () => {
+    it(
+      "finds files matching pattern",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "a.ts"), "a")
+        yield* fs.writeFileString(path.join(tmp, "b.ts"), "b")
+        yield* fs.writeFileString(path.join(tmp, "c.json"), "c")
+
+        const result = yield* fs.glob("*.ts", { cwd: tmp })
+        expect(result.sort()).toEqual(["a.ts", "b.ts"])
+      }),
+    )
+
+    it(
+      "supports absolute paths",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "file.txt"), "hello")
+
+        const result = yield* fs.glob("*.txt", { cwd: tmp, absolute: true })
+        expect(result).toEqual([path.join(tmp, "file.txt")])
+      }),
+    )
+  })
+
+  describe("globMatch", () => {
+    it(
+      "matches patterns",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        expect(fs.globMatch("*.ts", "foo.ts")).toBe(true)
+        expect(fs.globMatch("*.ts", "foo.json")).toBe(false)
+        expect(fs.globMatch("src/**", "src/a/b.ts")).toBe(true)
+      }),
+    )
+  })
+
+  describe("globUp", () => {
+    it(
+      "finds files walking up directories",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        yield* fs.writeFileString(path.join(tmp, "root.md"), "root")
+        const child = path.join(tmp, "a", "b")
+        yield* fs.makeDirectory(child, { recursive: true })
+        yield* fs.writeFileString(path.join(child, "leaf.md"), "leaf")
+
+        const result = yield* fs.globUp("*.md", child, tmp)
+        expect(result).toContain(path.join(child, "leaf.md"))
+        expect(result).toContain(path.join(tmp, "root.md"))
+      }),
+    )
+  })
+
+  describe("built-in passthrough", () => {
+    it(
+      "exists works",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "exists.txt")
+        yield* fs.writeFileString(file, "yes")
+
+        expect(yield* fs.exists(file)).toBe(true)
+        expect(yield* fs.exists(file + ".nope")).toBe(false)
+      }),
+    )
+
+    it(
+      "remove works",
+      Effect.gen(function* () {
+        const fs = yield* AppFileSystem.Service
+        const tmp = yield* fs.makeTempDirectoryScoped()
+        const file = path.join(tmp, "delete-me.txt")
+        yield* fs.writeFileString(file, "bye")
+
+        yield* fs.remove(file)
+
+        expect(yield* fs.exists(file)).toBe(false)
+      }),
+    )
+  })
+
+  describe("pure helpers", () => {
+    test("mimeType returns correct types", () => {
+      expect(AppFileSystem.mimeType("file.json")).toBe("application/json")
+      expect(AppFileSystem.mimeType("image.png")).toBe("image/png")
+      expect(AppFileSystem.mimeType("unknown.qzx")).toBe("application/octet-stream")
+    })
+
+    test("contains checks path containment", () => {
+      expect(AppFileSystem.contains("/a/b", "/a/b/c")).toBe(true)
+      expect(AppFileSystem.contains("/a/b", "/a/c")).toBe(false)
+    })
+
+    test("overlaps detects overlapping paths", () => {
+      expect(AppFileSystem.overlaps("/a/b", "/a/b/c")).toBe(true)
+      expect(AppFileSystem.overlaps("/a/b/c", "/a/b")).toBe(true)
+      expect(AppFileSystem.overlaps("/a", "/b")).toBe(false)
+    })
+  })
+})
--- a/packages/opencode/test/provider/amazon-bedrock.test.ts
+++ b/packages/opencode/test/provider/amazon-bedrock.test.ts
@@ -2,6 +2,7 @@ import { test, expect, describe } from "bun:test"
 import path from "path"
 import { unlink } from "fs/promises"

+import { ProviderID } from "../../src/provider/schema"
 import { tmpdir } from "../fixture/fixture"
 import { Instance } from "../../src/project/instance"
 import { Provider } from "../../src/provider/provider"
@@ -35,8 +36,8 @@ test("Bedrock: config region takes precedence over AWS_REGION env var", async ()
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].options?.region).toBe("eu-west-1")
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
    },
  })
 })
@@ -60,8 +61,8 @@ test("Bedrock: falls back to AWS_REGION env var when no config region", async ()
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].options?.region).toBe("eu-west-1")
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
    },
  })
 })
@@ -116,8 +117,8 @@ test("Bedrock: loads when bearer token from auth.json is present", async () => {
      },
      fn: async () => {
        const providers = await Provider.list()
-        expect(providers["amazon-bedrock"]).toBeDefined()
-        expect(providers["amazon-bedrock"].options?.region).toBe("eu-west-1")
+        expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+        expect(providers[ProviderID.amazonBedrock].options?.region).toBe("eu-west-1")
      },
    })
  } finally {
@@ -161,8 +162,8 @@ test("Bedrock: config profile takes precedence over AWS_PROFILE env var", async
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].options?.region).toBe("us-east-1")
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].options?.region).toBe("us-east-1")
    },
  })
 })
@@ -192,8 +193,8 @@ test("Bedrock: includes custom endpoint in options when specified", async () =>
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].options?.endpoint).toBe(
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].options?.endpoint).toBe(
        "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com",
      )
    },
@@ -228,8 +229,8 @@ test("Bedrock: autoloads when AWS_WEB_IDENTITY_TOKEN_FILE is present", async ()
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].options?.region).toBe("us-east-1")
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].options?.region).toBe("us-east-1")
    },
  })
 })
@@ -268,9 +269,9 @@ test("Bedrock: model with us. prefix should not be double-prefixed", async () =>
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
      // The model should exist with the us. prefix
-      expect(providers["amazon-bedrock"].models["us.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].models["us.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
    },
  })
 })
@@ -305,8 +306,8 @@ test("Bedrock: model with global. prefix should not be prefixed", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].models["global.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].models["global.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
    },
  })
 })
@@ -341,8 +342,8 @@ test("Bedrock: model with eu. prefix should not be double-prefixed", async () =>
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
-      expect(providers["amazon-bedrock"].models["eu.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].models["eu.anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
    },
  })
 })
@@ -377,9 +378,9 @@ test("Bedrock: model without prefix in US region should get us. prefix added", a
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["amazon-bedrock"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock]).toBeDefined()
      // Non-prefixed model should still be registered
-      expect(providers["amazon-bedrock"].models["anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
+      expect(providers[ProviderID.amazonBedrock].models["anthropic.claude-opus-4-5-20251101-v1:0"]).toBeDefined()
    },
  })
 })
--- a/packages/opencode/test/provider/gitlab-duo.test.ts
+++ b/packages/opencode/test/provider/gitlab-duo.test.ts
@@ -1,6 +1,7 @@
 import { test, expect } from "bun:test"
 import path from "path"

+import { ProviderID } from "../../src/provider/schema"
 import { tmpdir } from "../fixture/fixture"
 import { Instance } from "../../src/project/instance"
 import { Provider } from "../../src/provider/provider"
@@ -25,8 +26,8 @@ test("GitLab Duo: loads provider with API key from environment", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].key).toBe("test-gitlab-token")
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].key).toBe("test-gitlab-token")
    },
  })
 })
@@ -57,8 +58,8 @@ test("GitLab Duo: config instanceUrl option sets baseURL", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].options?.instanceUrl).toBe("https://gitlab.example.com")
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].options?.instanceUrl).toBe("https://gitlab.example.com")
    },
  })
 })
@@ -95,7 +96,7 @@ test("GitLab Duo: loads with OAuth token from auth.json", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
+      expect(providers[ProviderID.gitlab]).toBeDefined()
    },
  })
 })
@@ -130,8 +131,8 @@ test("GitLab Duo: loads with Personal Access Token from auth.json", async () =>
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].key).toBe("glpat-test-pat-token")
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].key).toBe("glpat-test-pat-token")
    },
  })
 })
@@ -162,8 +163,8 @@ test("GitLab Duo: supports self-hosted instance configuration", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].options?.instanceUrl).toBe("https://gitlab.company.internal")
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].options?.instanceUrl).toBe("https://gitlab.company.internal")
    },
  })
 })
@@ -193,7 +194,7 @@ test("GitLab Duo: config apiKey takes precedence over environment variable", asy
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
+      expect(providers[ProviderID.gitlab]).toBeDefined()
    },
  })
 })
@@ -216,8 +217,10 @@ test("GitLab Duo: includes context-1m beta header in aiGatewayHeaders", async ()
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].options?.aiGatewayHeaders?.["anthropic-beta"]).toContain("context-1m-2025-08-07")
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].options?.aiGatewayHeaders?.["anthropic-beta"]).toContain(
+        "context-1m-2025-08-07",
+      )
    },
  })
 })
@@ -250,9 +253,9 @@ test("GitLab Duo: supports feature flags configuration", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      expect(providers["gitlab"].options?.featureFlags).toBeDefined()
-      expect(providers["gitlab"].options?.featureFlags?.duo_agent_platform_agentic_chat).toBe(true)
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      expect(providers[ProviderID.gitlab].options?.featureFlags).toBeDefined()
+      expect(providers[ProviderID.gitlab].options?.featureFlags?.duo_agent_platform_agentic_chat).toBe(true)
    },
  })
 })
@@ -275,8 +278,8 @@ test("GitLab Duo: has multiple agentic chat models available", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["gitlab"]).toBeDefined()
-      const models = Object.keys(providers["gitlab"].models)
+      expect(providers[ProviderID.gitlab]).toBeDefined()
+      const models = Object.keys(providers[ProviderID.gitlab].models)
      expect(models.length).toBeGreaterThan(0)
      expect(models).toContain("duo-chat-haiku-4-5")
      expect(models).toContain("duo-chat-sonnet-4-5")
--- a/packages/opencode/test/provider/provider.test.ts
+++ b/packages/opencode/test/provider/provider.test.ts
@@ -25,11 +25,11 @@ test("provider loaded from env variable", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
+      expect(providers[ProviderID.anthropic]).toBeDefined()
      // Provider should retain its connection source even if custom loaders
      // merge additional options.
-      expect(providers["anthropic"].source).toBe("env")
-      expect(providers["anthropic"].options.headers["anthropic-beta"]).toBeDefined()
+      expect(providers[ProviderID.anthropic].source).toBe("env")
+      expect(providers[ProviderID.anthropic].options.headers["anthropic-beta"]).toBeDefined()
    },
  })
 })
@@ -56,7 +56,7 @@ test("provider loaded from config with apiKey option", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
+      expect(providers[ProviderID.anthropic]).toBeDefined()
    },
  })
 })
@@ -80,7 +80,7 @@ test("disabled_providers excludes provider", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeUndefined()
+      expect(providers[ProviderID.anthropic]).toBeUndefined()
    },
  })
 })
@@ -105,8 +105,8 @@ test("enabled_providers restricts to only listed providers", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      expect(providers["openai"]).toBeUndefined()
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      expect(providers[ProviderID.openai]).toBeUndefined()
    },
  })
 })
@@ -134,8 +134,8 @@ test("model whitelist filters models for provider", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      const models = Object.keys(providers["anthropic"].models)
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      const models = Object.keys(providers[ProviderID.anthropic].models)
      expect(models).toContain("claude-sonnet-4-20250514")
      expect(models.length).toBe(1)
    },
@@ -165,8 +165,8 @@ test("model blacklist excludes specific models", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      const models = Object.keys(providers["anthropic"].models)
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      const models = Object.keys(providers[ProviderID.anthropic].models)
      expect(models).not.toContain("claude-sonnet-4-20250514")
    },
  })
@@ -200,9 +200,9 @@ test("custom model alias via config", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      expect(providers["anthropic"].models["my-alias"]).toBeDefined()
-      expect(providers["anthropic"].models["my-alias"].name).toBe("My Custom Alias")
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      expect(providers[ProviderID.anthropic].models["my-alias"]).toBeDefined()
+      expect(providers[ProviderID.anthropic].models["my-alias"].name).toBe("My Custom Alias")
    },
  })
 })
@@ -243,9 +243,9 @@ test("custom provider with npm package", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["custom-provider"]).toBeDefined()
-      expect(providers["custom-provider"].name).toBe("Custom Provider")
-      expect(providers["custom-provider"].models["custom-model"]).toBeDefined()
+      expect(providers[ProviderID.make("custom-provider")]).toBeDefined()
+      expect(providers[ProviderID.make("custom-provider")].name).toBe("Custom Provider")
+      expect(providers[ProviderID.make("custom-provider")].models["custom-model"]).toBeDefined()
    },
  })
 })
@@ -276,10 +276,10 @@ test("env variable takes precedence, config merges options", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
+      expect(providers[ProviderID.anthropic]).toBeDefined()
      // Config options should be merged
-      expect(providers["anthropic"].options.timeout).toBe(60000)
-      expect(providers["anthropic"].options.chunkTimeout).toBe(15000)
+      expect(providers[ProviderID.anthropic].options.timeout).toBe(60000)
+      expect(providers[ProviderID.anthropic].options.chunkTimeout).toBe(15000)
    },
  })
 })
@@ -446,8 +446,8 @@ test("provider with baseURL from config", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["custom-openai"]).toBeDefined()
-      expect(providers["custom-openai"].options.baseURL).toBe("https://custom.openai.com/v1")
+      expect(providers[ProviderID.make("custom-openai")]).toBeDefined()
+      expect(providers[ProviderID.make("custom-openai")].options.baseURL).toBe("https://custom.openai.com/v1")
    },
  })
 })
@@ -484,7 +484,7 @@ test("model cost defaults to zero when not specified", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["test-provider"].models["test-model"]
+      const model = providers[ProviderID.make("test-provider")].models["test-model"]
      expect(model.cost.input).toBe(0)
      expect(model.cost.output).toBe(0)
      expect(model.cost.cache.read).toBe(0)
@@ -522,7 +522,7 @@ test("model options are merged from existing model", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.options.customOption).toBe("custom-value")
    },
  })
@@ -551,7 +551,7 @@ test("provider removed when all models filtered out", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeUndefined()
+      expect(providers[ProviderID.anthropic]).toBeUndefined()
    },
  })
 })
@@ -629,7 +629,7 @@ test("getModel uses realIdByKey for aliased models", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"].models["my-sonnet"]).toBeDefined()
+      expect(providers[ProviderID.anthropic].models["my-sonnet"]).toBeDefined()

      const model = await Provider.getModel(ProviderID.anthropic, ModelID.make("my-sonnet"))
      expect(model).toBeDefined()
@@ -673,7 +673,7 @@ test("provider api field sets model api.url", async () => {
    fn: async () => {
      const providers = await Provider.list()
      // api field is stored on model.api.url, used by getSDK to set baseURL
-      expect(providers["custom-api"].models["model-1"].api.url).toBe("https://api.example.com/v1")
+      expect(providers[ProviderID.make("custom-api")].models["model-1"].api.url).toBe("https://api.example.com/v1")
    },
  })
 })
@@ -712,7 +712,7 @@ test("explicit baseURL overrides api field", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["custom-api"].options.baseURL).toBe("https://custom.override.com/v1")
+      expect(providers[ProviderID.make("custom-api")].options.baseURL).toBe("https://custom.override.com/v1")
    },
  })
 })
@@ -744,7 +744,7 @@ test("model inherits properties from existing database model", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.name).toBe("Custom Name for Sonnet")
      expect(model.capabilities.toolcall).toBe(true)
      expect(model.capabilities.attachment).toBe(true)
@@ -772,7 +772,7 @@ test("disabled_providers prevents loading even with env var", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["openai"]).toBeUndefined()
+      expect(providers[ProviderID.openai]).toBeUndefined()
    },
  })
 })
@@ -826,8 +826,8 @@ test("whitelist and blacklist can be combined", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      const models = Object.keys(providers["anthropic"].models)
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      const models = Object.keys(providers[ProviderID.anthropic].models)
      expect(models).toContain("claude-sonnet-4-20250514")
      expect(models).not.toContain("claude-opus-4-20250514")
      expect(models.length).toBe(1)
@@ -865,7 +865,7 @@ test("model modalities default correctly", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["test-provider"].models["test-model"]
+      const model = providers[ProviderID.make("test-provider")].models["test-model"]
      expect(model.capabilities.input.text).toBe(true)
      expect(model.capabilities.output.text).toBe(true)
    },
@@ -908,7 +908,7 @@ test("model with custom cost values", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["test-provider"].models["test-model"]
+      const model = providers[ProviderID.make("test-provider")].models["test-model"]
      expect(model.cost.input).toBe(5)
      expect(model.cost.output).toBe(15)
      expect(model.cost.cache.read).toBe(2.5)
@@ -1009,10 +1009,10 @@ test("multiple providers can be configured simultaneously", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"]).toBeDefined()
-      expect(providers["openai"]).toBeDefined()
-      expect(providers["anthropic"].options.timeout).toBe(30000)
-      expect(providers["openai"].options.timeout).toBe(60000)
+      expect(providers[ProviderID.anthropic]).toBeDefined()
+      expect(providers[ProviderID.openai]).toBeDefined()
+      expect(providers[ProviderID.anthropic].options.timeout).toBe(30000)
+      expect(providers[ProviderID.openai].options.timeout).toBe(60000)
    },
  })
 })
@@ -1050,9 +1050,9 @@ test("provider with custom npm package", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["local-llm"]).toBeDefined()
-      expect(providers["local-llm"].models["llama-3"].api.npm).toBe("@ai-sdk/openai-compatible")
-      expect(providers["local-llm"].options.baseURL).toBe("http://localhost:11434/v1")
+      expect(providers[ProviderID.make("local-llm")]).toBeDefined()
+      expect(providers[ProviderID.make("local-llm")].models["llama-3"].api.npm).toBe("@ai-sdk/openai-compatible")
+      expect(providers[ProviderID.make("local-llm")].options.baseURL).toBe("http://localhost:11434/v1")
    },
  })
 })
@@ -1087,7 +1087,7 @@ test("model alias name defaults to alias key when id differs", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["anthropic"].models["sonnet"].name).toBe("sonnet")
+      expect(providers[ProviderID.anthropic].models["sonnet"].name).toBe("sonnet")
    },
  })
 })
@@ -1127,9 +1127,9 @@ test("provider with multiple env var options only includes apiKey when single en
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["multi-env"]).toBeDefined()
+      expect(providers[ProviderID.make("multi-env")]).toBeDefined()
      // When multiple env options exist, key should NOT be auto-set
-      expect(providers["multi-env"].key).toBeUndefined()
+      expect(providers[ProviderID.make("multi-env")].key).toBeUndefined()
    },
  })
 })
@@ -1169,9 +1169,9 @@ test("provider with single env var includes apiKey automatically", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["single-env"]).toBeDefined()
+      expect(providers[ProviderID.make("single-env")]).toBeDefined()
      // Single env option should auto-set key
-      expect(providers["single-env"].key).toBe("my-api-key")
+      expect(providers[ProviderID.make("single-env")].key).toBe("my-api-key")
    },
  })
 })
@@ -1206,7 +1206,7 @@ test("model cost overrides existing cost values", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.cost.input).toBe(999)
      expect(model.cost.output).toBe(888)
    },
@@ -1253,9 +1253,9 @@ test("completely new provider not in database can be configured", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["brand-new-provider"]).toBeDefined()
-      expect(providers["brand-new-provider"].name).toBe("Brand New")
-      const model = providers["brand-new-provider"].models["new-model"]
+      expect(providers[ProviderID.make("brand-new-provider")]).toBeDefined()
+      expect(providers[ProviderID.make("brand-new-provider")].name).toBe("Brand New")
+      const model = providers[ProviderID.make("brand-new-provider")].models["new-model"]
      expect(model.capabilities.reasoning).toBe(true)
      expect(model.capabilities.attachment).toBe(true)
      expect(model.capabilities.input.image).toBe(true)
@@ -1288,11 +1288,11 @@ test("disabled_providers and enabled_providers interaction", async () => {
    fn: async () => {
      const providers = await Provider.list()
      // anthropic: in enabled, not in disabled = allowed
-      expect(providers["anthropic"]).toBeDefined()
+      expect(providers[ProviderID.anthropic]).toBeDefined()
      // openai: in enabled, but also in disabled = NOT allowed
-      expect(providers["openai"]).toBeUndefined()
+      expect(providers[ProviderID.openai]).toBeUndefined()
      // google: not in enabled = NOT allowed (even though not disabled)
-      expect(providers["google"]).toBeUndefined()
+      expect(providers[ProviderID.google]).toBeUndefined()
    },
  })
 })
@@ -1327,7 +1327,7 @@ test("model with tool_call false", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["no-tools"].models["basic-model"].capabilities.toolcall).toBe(false)
+      expect(providers[ProviderID.make("no-tools")].models["basic-model"].capabilities.toolcall).toBe(false)
    },
  })
 })
@@ -1362,7 +1362,7 @@ test("model defaults tool_call to true when not specified", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["default-tools"].models["model"].capabilities.toolcall).toBe(true)
+      expect(providers[ProviderID.make("default-tools")].models["model"].capabilities.toolcall).toBe(true)
    },
  })
 })
@@ -1401,7 +1401,7 @@ test("model headers are preserved", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["headers-provider"].models["model"]
+      const model = providers[ProviderID.make("headers-provider")].models["model"]
      expect(model.headers).toEqual({
        "X-Custom-Header": "custom-value",
        Authorization: "Bearer special-token",
@@ -1445,7 +1445,7 @@ test("provider env fallback - second env var used if first missing", async () =>
    fn: async () => {
      const providers = await Provider.list()
      // Provider should load because fallback env var is set
-      expect(providers["fallback-env"]).toBeDefined()
+      expect(providers[ProviderID.make("fallback-env")]).toBeDefined()
    },
  })
 })
@@ -1506,7 +1506,7 @@ test("provider name defaults to id when not in database", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["my-custom-id"].name).toBe("my-custom-id")
+      expect(providers[ProviderID.make("my-custom-id")].name).toBe("my-custom-id")
    },
  })
 })
@@ -1689,7 +1689,7 @@ test("model limit defaults to zero when not specified", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["no-limit"].models["model"]
+      const model = providers[ProviderID.make("no-limit")].models["model"]
      expect(model.limit.context).toBe(0)
      expect(model.limit.output).toBe(0)
    },
@@ -1725,10 +1725,10 @@ test("provider options are deeply merged", async () => {
    fn: async () => {
      const providers = await Provider.list()
      // Custom options should be merged
-      expect(providers["anthropic"].options.timeout).toBe(30000)
-      expect(providers["anthropic"].options.headers["X-Custom"]).toBe("custom-value")
+      expect(providers[ProviderID.anthropic].options.timeout).toBe(30000)
+      expect(providers[ProviderID.anthropic].options.headers["X-Custom"]).toBe("custom-value")
      // anthropic custom loader adds its own headers, they should coexist
-      expect(providers["anthropic"].options.headers["anthropic-beta"]).toBeDefined()
+      expect(providers[ProviderID.anthropic].options.headers["anthropic-beta"]).toBeDefined()
    },
  })
 })
@@ -1762,7 +1762,7 @@ test("custom model inherits npm package from models.dev provider config", async
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["openai"].models["my-custom-model"]
+      const model = providers[ProviderID.openai].models["my-custom-model"]
      expect(model).toBeDefined()
      expect(model.api.npm).toBe("@ai-sdk/openai")
    },
@@ -1797,15 +1797,15 @@ test("custom model inherits api.url from models.dev provider", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["openrouter"]).toBeDefined()
+      expect(providers[ProviderID.openrouter]).toBeDefined()

      // New model not in database should inherit api.url from provider
-      const intellect = providers["openrouter"].models["prime-intellect/intellect-3"]
+      const intellect = providers[ProviderID.openrouter].models["prime-intellect/intellect-3"]
      expect(intellect).toBeDefined()
      expect(intellect.api.url).toBe("https://openrouter.ai/api/v1")

      // Another new model should also inherit api.url
-      const deepseek = providers["openrouter"].models["deepseek/deepseek-r1-0528"]
+      const deepseek = providers[ProviderID.openrouter].models["deepseek/deepseek-r1-0528"]
      expect(deepseek).toBeDefined()
      expect(deepseek.api.url).toBe("https://openrouter.ai/api/v1")
      expect(deepseek.name).toBe("DeepSeek R1")
@@ -1832,7 +1832,7 @@ test("model variants are generated for reasoning models", async () => {
    fn: async () => {
      const providers = await Provider.list()
      // Claude sonnet 4 has reasoning capability
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.capabilities.reasoning).toBe(true)
      expect(model.variants).toBeDefined()
      expect(Object.keys(model.variants!).length).toBeGreaterThan(0)
@@ -1869,7 +1869,7 @@ test("model variants can be disabled via config", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.variants).toBeDefined()
      expect(model.variants!["high"]).toBeUndefined()
      // max variant should still exist
@@ -1912,7 +1912,7 @@ test("model variants can be customized via config", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.variants!["high"]).toBeDefined()
      expect(model.variants!["high"].thinking.budgetTokens).toBe(20000)
    },
@@ -1951,7 +1951,7 @@ test("disabled key is stripped from variant config", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.variants!["max"]).toBeDefined()
      expect(model.variants!["max"].disabled).toBeUndefined()
      expect(model.variants!["max"].customField).toBe("test")
@@ -1989,7 +1989,7 @@ test("all variants can be disabled via config", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.variants).toBeDefined()
      expect(Object.keys(model.variants!).length).toBe(0)
    },
@@ -2027,7 +2027,7 @@ test("variant config merges with generated variants", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["anthropic"].models["claude-sonnet-4-20250514"]
+      const model = providers[ProviderID.anthropic].models["claude-sonnet-4-20250514"]
      expect(model.variants!["high"]).toBeDefined()
      // Should have both the generated thinking config and the custom option
      expect(model.variants!["high"].thinking).toBeDefined()
@@ -2065,7 +2065,7 @@ test("variants filtered in second pass for database models", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["openai"].models["gpt-5"]
+      const model = providers[ProviderID.openai].models["gpt-5"]
      expect(model.variants).toBeDefined()
      expect(model.variants!["high"]).toBeUndefined()
      // Other variants should still exist
@@ -2111,7 +2111,7 @@ test("custom model with variants enabled and disabled", async () => {
    directory: tmp.path,
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["custom-reasoning"].models["reasoning-model"]
+      const model = providers[ProviderID.make("custom-reasoning")].models["reasoning-model"]
      expect(model.variants).toBeDefined()
      // Enabled variants should exist
      expect(model.variants!["low"]).toBeDefined()
@@ -2169,8 +2169,8 @@ test("Google Vertex: retains baseURL for custom proxy", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["vertex-proxy"]).toBeDefined()
-      expect(providers["vertex-proxy"].options.baseURL).toBe("https://my-proxy.com/v1")
+      expect(providers[ProviderID.make("vertex-proxy")]).toBeDefined()
+      expect(providers[ProviderID.make("vertex-proxy")].options.baseURL).toBe("https://my-proxy.com/v1")
    },
  })
 })
@@ -2214,7 +2214,7 @@ test("Google Vertex: supports OpenAI compatible models", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      const model = providers["vertex-openai"].models["gpt-4"]
+      const model = providers[ProviderID.make("vertex-openai")].models["gpt-4"]

      expect(model).toBeDefined()
      expect(model.api.npm).toBe("@ai-sdk/openai-compatible")
@@ -2242,7 +2242,7 @@ test("cloudflare-ai-gateway loads with env variables", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["cloudflare-ai-gateway"]).toBeDefined()
+      expect(providers[ProviderID.make("cloudflare-ai-gateway")]).toBeDefined()
    },
  })
 })
@@ -2274,8 +2274,8 @@ test("cloudflare-ai-gateway forwards config metadata options", async () => {
    },
    fn: async () => {
      const providers = await Provider.list()
-      expect(providers["cloudflare-ai-gateway"]).toBeDefined()
-      expect(providers["cloudflare-ai-gateway"].options.metadata).toEqual({
+      expect(providers[ProviderID.make("cloudflare-ai-gateway")]).toBeDefined()
+      expect(providers[ProviderID.make("cloudflare-ai-gateway")].options.metadata).toEqual({
        invoked_by: "test",
        project: "opencode",
      })
--- a/packages/opencode/test/session/message-v2.test.ts
+++ b/packages/opencode/test/session/message-v2.test.ts
@@ -4,6 +4,7 @@ import { MessageV2 } from "../../src/session/message-v2"
 import type { Provider } from "../../src/provider/provider"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { SessionID, MessageID, PartID } from "../../src/session/schema"
+import { Question } from "../../src/question"

 const sessionID = SessionID.make("session")
 const providerID = ProviderID.make("test")
@@ -915,4 +916,15 @@ describe("session.message-v2.fromError", () => {
      },
    })
  })
+
+  test("serializes tagged errors with their message", () => {
+    const result = MessageV2.fromError(new Question.RejectedError(), { providerID })
+
+    expect(result).toStrictEqual({
+      name: "UnknownError",
+      data: {
+        message: "The user dismissed this question",
+      },
+    })
+  })
 })
--- a/packages/opencode/test/util/process.test.ts
+++ b/packages/opencode/test/util/process.test.ts
@@ -109,4 +109,20 @@ describe("util.process", () => {

    expect(await proc.exited).toBe(0)
  })
+
+  test("rejects missing commands without leaking unhandled errors", async () => {
+    await using tmp = await tmpdir()
+    const cmd = path.join(tmp.path, "missing" + (process.platform === "win32" ? ".cmd" : ""))
+    const err = await Process.spawn([cmd], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    }).exited.catch((err) => err)
+
+    expect(err).toBeInstanceOf(Error)
+    if (!(err instanceof Error)) throw err
+    expect(err).toMatchObject({
+      code: "ENOENT",
+    })
+  })
 })
--- a/packages/plugin/src/index.ts
+++ b/packages/plugin/src/index.ts
@@ -159,6 +159,18 @@ export type AuthOuathResult = { url: string; instructions: string } & (
    }
 )

+export type ProviderHook = {
+  id: string
+  models?: {
+    reconcile?: (input: {
+      provider: Provider
+      models: Record<string, Model>
+      auth?: Auth
+      options?: Record<string, unknown>
+    }) => Promise<Record<string, Model> | undefined>
+  }
+}
+
 export interface Hooks {
  event?: (input: { event: Event }) => Promise<void>
  config?: (input: Config) => Promise<void>
@@ -166,6 +178,7 @@ export interface Hooks {
    [key: string]: ToolDefinition
  }
  auth?: AuthHook
+  provider?: ProviderHook
  /**
   * Called when a new message is received
   */
--- a/packages/web/src/content/docs/zen.mdx
+++ b/packages/web/src/content/docs/zen.mdx
@@ -94,7 +94,8 @@ You can also access our models through the following API endpoints.
 | GLM 5                 | glm-5                 | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
 | Kimi K2.5             | kimi-k2.5             | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
 | Big Pickle            | big-pickle            | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
-| MiMo V2 Flash Free    | mimo-v2-flash-free    | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
+| MiMo V2 Pro Free      | mimo-v2-pro-free      | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
+| MiMo V2 Omni Free     | mimo-v2-omni-free     | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |
 | Nemotron 3 Super Free | nemotron-3-super-free | `https://opencode.ai/zen/v1/chat/completions`      | `@ai-sdk/openai-compatible` |

 The [model id](/docs/config/#models) in your OpenCode config
@@ -120,7 +121,8 @@ We support a pay-as-you-go model. Below are the prices **per 1M tokens**.
 | Model                             | Input  | Output  | Cached Read | Cached Write |
 | --------------------------------- | ------ | ------- | ----------- | ------------ |
 | Big Pickle                        | Free   | Free    | Free        | -            |
-| MiMo V2 Flash Free                | Free   | Free    | Free        | -            |
+| MiMo V2 Pro Free                  | Free   | Free    | Free        | -            |
+| MiMo V2 Omni Free                 | Free   | Free    | Free        | -            |
 | Nemotron 3 Super Free             | Free   | Free    | Free        | -            |
 | MiniMax M2.5 Free                 | Free   | Free    | Free        | -            |
 | MiniMax M2.5                      | $0.30  | $1.20   | $0.06       | $0.375       |
@@ -165,7 +167,8 @@ Credit card fees are passed along at cost (4.4% + $0.30 per transaction); we don
 The free models:

 - MiniMax M2.5 Free is available on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.
- MiMo V2 Flash Free is available on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.
+- MiMo V2 Pro Free is available on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.
+- MiMo V2 Omni Free is available on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.
 - Nemotron 3 Super Free is available on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.
 - Big Pickle is a stealth model that's free on OpenCode for a limited time. The team is using this time to collect feedback and improve the model.

@@ -212,7 +215,8 @@ All our models are hosted in the US. Our providers follow a zero-retention polic

 - Big Pickle: During its free period, collected data may be used to improve the model.
 - MiniMax M2.5 Free: During its free period, collected data may be used to improve the model.
- MiniMax M2.5 Free: During its free period, collected data may be used to improve the model.
+- MiMo V2 Pro Free: During its free period, collected data may be used to improve the model.
+- MiMo V2 Omni Free: During its free period, collected data may be used to improve the model.
 - Nemotron 3 Super Free: During its free period, collected data may be used to improve the model.
 - OpenAI APIs: Requests are retained for 30 days in accordance with [OpenAI's Data Policies](https://platform.openai.com/docs/guides/your-data).
 - Anthropic APIs: Requests are retained for 30 days in accordance with [Anthropic's Data Policies](https://docs.anthropic.com/en/docs/claude-code/data-usage).
Author	SHA1	Message	Date
Aiden Cline	2c968ed108	rm	2026-03-19 00:00:02 -05:00
Aiden Cline	b3182149c8	gitlab integration poc	2026-03-18 23:59:50 -05:00
Aiden Cline	d95fd77861	Merge branch 'dev' into add-model-reconciliation	2026-03-18 21:58:45 -05:00
Kit Langton	84e62fc662	fix(session): preserve tagged error messages (#18165 )	2026-03-18 20:36:53 -04:00
Frank	a7ea93528b	zen: add mimo pro/omni models	2026-03-18 20:28:41 -04:00
opencode-agent[bot]	d90e3a2833	chore: update nix node_modules hashes	2026-03-19 00:08:27 +00:00
opencode-agent[bot]	1c74c2741a	chore: update nix node_modules hashes	2026-03-19 00:07:30 +00:00
Luke Parker	5d2f8d77f9	fix: restore recent test regressions and upgrade effect beta (#18158 )	2026-03-19 09:54:01 +10:00
Kit Langton	81be544981	feat(filesystem): add AppFileSystem service, migrate Snapshot (#18138 )	2026-03-18 19:52:43 -04:00
opencode-agent[bot]	773c1192dc	chore: generate	2026-03-18 23:45:03 +00:00
Kit Langton	5ddfe4ada5	chore: type Provider.list() as Record<ProviderID, Info>, delete dead code (#18123 )	2026-03-18 19:43:12 -04:00
Aiden Cline	c32c2e8a8f	feat: add model reconciliation hook	2026-03-18 18:16:00 -05:00