refactor: rename workspace adapters

2026-04-29 20:27:20 -04:00
125 changed files with 4321 additions and 7828 deletions
@@ -16,7 +16,6 @@ ariane-emory
 -danieljoshuanazareth
 -danieljoshuanazareth
 -davidbernat looks to be a clawdbot that spams team and sends super weird emails, doesnt appear to be a real person
-dmtrkovalenko
 edemaine
 fahreddinozcan
 -florianleibert
@@ -88,7 +88,7 @@ jobs:
      - name: Build
        id: build
        run: |
-          ./packages/opencode/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
+          ./packages/opencode/script/build.ts
        env:
          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
          OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
@@ -28,11 +28,3 @@ Use the current Effect v4 / effect-smol source, not memory or older Effect v2/v3
 - In tests, prefer the repo's existing Effect test helpers and live tests for filesystem, git, child process, locks, or timing behavior.
 - Do not introduce `any`, non-null assertions, unchecked casts, or older Effect APIs just to satisfy types.
 - Do not answer from memory. Verify against `.opencode/references/effect-smol` or nearby code first.
-
-## Testing Patterns
-
- Use `testEffect(...)` from `packages/opencode/test/lib/effect.ts` for tests that exercise Effect services, layers, runtime context, scoped resources, or platform integrations.
- Use `it.live(...)` for filesystem, git repositories, HTTP servers, sockets, child processes, locks, real time, and other live platform behavior.
- Run tests from package directories such as `packages/opencode`; never run package tests from the repo root.
- Prefer explicit test layers over ad hoc managed runtimes. Keep dependency provisioning visible in the test file.
- Use scoped fixtures and finalizers for resources that must be cleaned up, including temporary directories, flags, databases, fibers, servers, and global state.
@@ -506,8 +506,8 @@
        "typescript": "catalog:",
      },
      "peerDependencies": {
-        "@opentui/core": ">=0.2.0",
-        "@opentui/solid": ">=0.2.0",
+        "@opentui/core": ">=0.1.105",
+        "@opentui/solid": ">=0.1.105",
      },
      "optionalPeers": [
        "@opentui/core",
@@ -685,8 +685,8 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.2.0",
-    "@opentui/solid": "0.2.0",
+    "@opentui/core": "0.1.105",
+    "@opentui/solid": "0.1.105",
    "@pierre/diffs": "1.1.0-beta.18",
    "@playwright/test": "1.59.1",
    "@solid-primitives/storage": "4.3.3",
@@ -1613,21 +1613,21 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.40.0", "", {}, "sha512-cifvXDhcqMwwTlTK04GBNeIe7yyo28Mfby85QXFe1Yk8nmi36Ab/5UQwptOx84SsoGNRg+EVSjwzfSZMy6pmlw=="],

-    "@opentui/core": ["@opentui/core@0.2.0", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.2.0", "@opentui/core-darwin-x64": "0.2.0", "@opentui/core-linux-arm64": "0.2.0", "@opentui/core-linux-x64": "0.2.0", "@opentui/core-win32-arm64": "0.2.0", "@opentui/core-win32-x64": "0.2.0", "bun-webgpu": "0.1.7", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-7YOEqPUQmsgrOb9nmLEBlX8RVHPFy4HquK1C489DwfvvPTiws8nTbZ+webNQDWha7shgnYQK4Zo1EcOlpQ5+1Q=="],
+    "@opentui/core": ["@opentui/core@0.1.105", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.1.105", "@opentui/core-darwin-x64": "0.1.105", "@opentui/core-linux-arm64": "0.1.105", "@opentui/core-linux-x64": "0.1.105", "@opentui/core-win32-arm64": "0.1.105", "@opentui/core-win32-x64": "0.1.105", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-vllSOOCW6VIThV/96GRLJ1IxIBuR+ci6FDvnPIAG4s7SJ/FW6zAkqDn1xrtBwwk/lM3QWjLqy8BZc+zwWvveJA=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.2.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-VVmKwth3hzsQPjAZ7WGJxmzuzx0uCtynd79JJDg26D7QRM9V5beVGbKwwU5SKsDlK74EyQoY85Mv9xFY5E4jrA=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.105", "", { "os": "darwin", "cpu": "arm64" }, "sha512-1pIL7aer9amwj8EpYoMNtvavKetIe+nX8uBRmYsMQb+KvJoUAZUqENfRW+qHE5WrsOyxx8/QoyXTHw15GG5iLQ=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.2.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-eX+WNdbSNr7Bozdq/MH6p1vXIALGt0SqBHR4YtWyTh6X7KDz9FTtJT3ylxMPqiVRUGBNAiWOxoqKGXW7JLQ0TA=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.105", "", { "os": "darwin", "cpu": "x64" }, "sha512-hLIRSWlK3gY2NRXJGWiTBiMYSmRDjOYFZF6WtUVXhY2SL3sp08dhmr/6dmAVH+3pKCsCipLEsrrcQX6SAihCTA=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.2.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-ARZa+ywbN/OV7esT5ZdJMlQW3a4Pr56qLlEI/X65ik88C2sgmDze4Kf2FmqtvJ1hbv1YsMfLHH9MfhLl5twyHQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.105", "", { "os": "linux", "cpu": "arm64" }, "sha512-jlRKfPkozTZEkHEePuCWYcTIUtPm+ieInAwGVqGmjbvqjxdVv1/W/Dt6LEZ/9jpRiOPd+FjXAfLe6wa/XWHr+w=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.2.0", "", { "os": "linux", "cpu": "x64" }, "sha512-ZjNxrD45P51cdbABoivVQLBakVYwDqAridJbHhkK6T/+EU7YsTrmAu9ae19N9ZGnrlKzLViQF8GOavNUNjAbhw=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.105", "", { "os": "linux", "cpu": "x64" }, "sha512-kfWS1WMg6qHShmxZX9s1tZc/8JcXw6uyy2UtyTbJdRFExtXGH37oKHi8QK8iPL2ExCx4z7zqVnVJfO3X/Wh7lA=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.2.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-ImMjFPOWE8wcZQ2lUz1D418xonS/5EwnItUF1g5dbp1q9+A0vv2P3bxTenLwMqcYvG4wjO6gKT3n2QLnRd6qKg=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.105", "", { "os": "win32", "cpu": "arm64" }, "sha512-UFx6A8OpBVbGWK6OAw4GqAqKZgIITJfSOd35pG9yDVKQouHN2OGc2HeeXrH2A4h42p40Xl6IfcqqfllkpC13Dg=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.2.0", "", { "os": "win32", "cpu": "x64" }, "sha512-6yfYHTtJ4yzbl8kXCW3Pc4eWbZDYVw21GumwdNgkjJJ2JqQAQ861em0riEoucYAa5qPYYTiMUEw7X4Fv8lGwuQ=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.105", "", { "os": "win32", "cpu": "x64" }, "sha512-f9FqqUmxehwhF+cgyazm0YT0v0BYTTCPzd6eztqhl74N3x/kC+jOOz2rdJDC/tTBo1JVsF64KupOnhIs6/Cogg=="],

-    "@opentui/solid": ["@opentui/solid@0.2.0", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.2.0", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-kZR9i0FPAcVtomrPsKuSb+D9smooplo9zggFfU2vnnguNuQjGNbEmuJtxhCacy7ig9g3GomdNtQAzD4LiAY+3w=="],
+    "@opentui/solid": ["@opentui/solid@0.1.105", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.105", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.10", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.11" } }, "sha512-uxnaMP802sCI487pv/Hk9xdFdIj9mkg3eNliAqbqR0Shmd4phcjKEZvPRpijjmI99j4s9nul71jzF3h1oz31Nw=="],

    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],

@@ -2731,15 +2731,15 @@

    "bun-types": ["bun-types@1.3.12", "", { "dependencies": { "@types/node": "*" } }, "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA=="],

-    "bun-webgpu": ["bun-webgpu@0.1.7", "", { "dependencies": { "@webgpu/types": "^0.1.60" }, "optionalDependencies": { "bun-webgpu-darwin-arm64": "^0.1.7", "bun-webgpu-darwin-x64": "^0.1.7", "bun-webgpu-linux-x64": "^0.1.7", "bun-webgpu-win32-x64": "^0.1.7" } }, "sha512-KUxUp+oQIf7pPBMD4Hv1TUu7DWaOZ4ciKulTk9to9+Uc8yHoYrMW7L2SJCJ4FHHkywgf/7aLRgRx0b7i6DvGIQ=="],
+    "bun-webgpu": ["bun-webgpu@0.1.5", "", { "dependencies": { "@webgpu/types": "^0.1.60" }, "optionalDependencies": { "bun-webgpu-darwin-arm64": "^0.1.5", "bun-webgpu-darwin-x64": "^0.1.5", "bun-webgpu-linux-x64": "^0.1.5", "bun-webgpu-win32-x64": "^0.1.5" } }, "sha512-91/K6S5whZKX7CWAm9AylhyKrLGRz6BUiiPiM/kXadSnD4rffljCD/q9cNFftm5YXhx4MvLqw33yEilxogJvwA=="],

-    "bun-webgpu-darwin-arm64": ["bun-webgpu-darwin-arm64@0.1.7", "", { "os": "darwin", "cpu": "arm64" }, "sha512-mRrFFyHzPWjsTRidAZBRcu808CPQBOUL0P6b4nxLhp+XHcV/mbUHERZMgW9s58tsojQfSdzschiQa8q+JCgRWA=="],
+    "bun-webgpu-darwin-arm64": ["bun-webgpu-darwin-arm64@0.1.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-lIsDkPzJzPl6yrB5CUOINJFPnTRv6fF/Q8J1mAr43ogSp86WZEg9XZKaT6f3EUJ+9ETogGoMnoj1q0AwHUTbAQ=="],

-    "bun-webgpu-darwin-x64": ["bun-webgpu-darwin-x64@0.1.7", "", { "os": "darwin", "cpu": "x64" }, "sha512-g0NXGNgvaVCSH/jCWWlfdiquOHkbUN6vP4zqzSkIxWKQeLnqm3oADcok7SO3yIgI7v5mKpRc/ks7NDEKNH+jNQ=="],
+    "bun-webgpu-darwin-x64": ["bun-webgpu-darwin-x64@0.1.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-uEddf5U7GvKIkM/BV18rUKtYHL6d0KeqBjNHwfqDH9QgEo9KVSKvJXS5I/sMefk5V5pIYE+8tQhtrREevhocng=="],

-    "bun-webgpu-linux-x64": ["bun-webgpu-linux-x64@0.1.7", "", { "os": "linux", "cpu": "x64" }, "sha512-UEP7UZdEhx9otvkZczjsszL8ZVlrODANQvgl+C88/bNVmxDoFi7w1fWzGi1sZyakiETjmtFDq2/xCLhbSZxjqw=="],
+    "bun-webgpu-linux-x64": ["bun-webgpu-linux-x64@0.1.6", "", { "os": "linux", "cpu": "x64" }, "sha512-Y/f15j9r8ba0xUz+3lATtS74OE+PPzQXO7Do/1eCluJcuOlfa77kMjvBK/ShWnem3Y9xqi59pebTPOGRB+CaJA=="],

-    "bun-webgpu-win32-x64": ["bun-webgpu-win32-x64@0.1.7", "", { "os": "win32", "cpu": "x64" }, "sha512-KZktiFkBz6sN7PEm1NVdeaLP5Q5X/PlSHZqefY4nNuWtf0LNvh54NhZe7yVv/Plz/nGbv92b0KHMBY3ki/pp6g=="],
+    "bun-webgpu-win32-x64": ["bun-webgpu-win32-x64@0.1.6", "", { "os": "win32", "cpu": "x64" }, "sha512-MHSFAKqizISb+C5NfDrFe3g0Al5Njnu0j/A+oO2Q+bIWX+fUYjBSowiYE1ZXJx65KuryuB+tiM7Qh6cQbVvkEg=="],

    "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],

@@ -5597,6 +5597,8 @@

    "@opentui/solid/@babel/core": ["@babel/core@7.28.0", "", { "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.0", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.27.3", "@babel/helpers": "^7.27.6", "@babel/parser": "^7.28.0", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.0", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ=="],

+    "@opentui/solid/babel-preset-solid": ["babel-preset-solid@1.9.10", "", { "dependencies": { "babel-plugin-jsx-dom-expressions": "^0.40.3" }, "peerDependencies": { "@babel/core": "^7.0.0", "solid-js": "^1.9.10" }, "optionalPeers": ["solid-js"] }, "sha512-HCelrgua/Y+kqO8RyL04JBWS/cVdrtUv/h45GntgQY+cJl4eBcKkCDV3TdMjtKx1nXwRaR9QXslM/Npm1dxdZQ=="],
+
    "@oslojs/jwt/@oslojs/encoding": ["@oslojs/encoding@0.4.1", "", {}, "sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q=="],

    "@pierre/diffs/@shikijs/transformers": ["@shikijs/transformers@3.20.0", "", { "dependencies": { "@shikijs/core": "3.20.0", "@shikijs/types": "3.20.0" } }, "sha512-PrHHMRr3Q5W1qB/42kJW6laqFyWdhrPF2hNR9qjOm1xcSiAO3hAHo7HaVyHE6pMyevmy3i51O8kuGGXC78uK3g=="],
@@ -5949,10 +5951,6 @@

    "openid-client/lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],

-    "opentui-spinner/@opentui/core": ["@opentui/core@0.1.105", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.1.105", "@opentui/core-darwin-x64": "0.1.105", "@opentui/core-linux-arm64": "0.1.105", "@opentui/core-linux-x64": "0.1.105", "@opentui/core-win32-arm64": "0.1.105", "@opentui/core-win32-x64": "0.1.105", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-vllSOOCW6VIThV/96GRLJ1IxIBuR+ci6FDvnPIAG4s7SJ/FW6zAkqDn1xrtBwwk/lM3QWjLqy8BZc+zwWvveJA=="],
-
-    "opentui-spinner/@opentui/solid": ["@opentui/solid@0.1.105", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.105", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.10", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.11" } }, "sha512-uxnaMP802sCI487pv/Hk9xdFdIj9mkg3eNliAqbqR0Shmd4phcjKEZvPRpijjmI99j4s9nul71jzF3h1oz31Nw=="],
-
    "ora/bl": ["bl@4.1.0", "", { "dependencies": { "buffer": "^5.5.0", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w=="],

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

    "opencontrol/@modelcontextprotocol/sdk/zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],

-    "opentui-spinner/@opentui/core/@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.105", "", { "os": "darwin", "cpu": "arm64" }, "sha512-1pIL7aer9amwj8EpYoMNtvavKetIe+nX8uBRmYsMQb+KvJoUAZUqENfRW+qHE5WrsOyxx8/QoyXTHw15GG5iLQ=="],
-
-    "opentui-spinner/@opentui/core/@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.105", "", { "os": "darwin", "cpu": "x64" }, "sha512-hLIRSWlK3gY2NRXJGWiTBiMYSmRDjOYFZF6WtUVXhY2SL3sp08dhmr/6dmAVH+3pKCsCipLEsrrcQX6SAihCTA=="],
-
-    "opentui-spinner/@opentui/core/@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.105", "", { "os": "linux", "cpu": "arm64" }, "sha512-jlRKfPkozTZEkHEePuCWYcTIUtPm+ieInAwGVqGmjbvqjxdVv1/W/Dt6LEZ/9jpRiOPd+FjXAfLe6wa/XWHr+w=="],
-
-    "opentui-spinner/@opentui/core/@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.105", "", { "os": "linux", "cpu": "x64" }, "sha512-kfWS1WMg6qHShmxZX9s1tZc/8JcXw6uyy2UtyTbJdRFExtXGH37oKHi8QK8iPL2ExCx4z7zqVnVJfO3X/Wh7lA=="],
-
-    "opentui-spinner/@opentui/core/@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.105", "", { "os": "win32", "cpu": "arm64" }, "sha512-UFx6A8OpBVbGWK6OAw4GqAqKZgIITJfSOd35pG9yDVKQouHN2OGc2HeeXrH2A4h42p40Xl6IfcqqfllkpC13Dg=="],
-
-    "opentui-spinner/@opentui/core/@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.105", "", { "os": "win32", "cpu": "x64" }, "sha512-f9FqqUmxehwhF+cgyazm0YT0v0BYTTCPzd6eztqhl74N3x/kC+jOOz2rdJDC/tTBo1JVsF64KupOnhIs6/Cogg=="],
-
-    "opentui-spinner/@opentui/core/bun-webgpu": ["bun-webgpu@0.1.5", "", { "dependencies": { "@webgpu/types": "^0.1.60" }, "optionalDependencies": { "bun-webgpu-darwin-arm64": "^0.1.5", "bun-webgpu-darwin-x64": "^0.1.5", "bun-webgpu-linux-x64": "^0.1.5", "bun-webgpu-win32-x64": "^0.1.5" } }, "sha512-91/K6S5whZKX7CWAm9AylhyKrLGRz6BUiiPiM/kXadSnD4rffljCD/q9cNFftm5YXhx4MvLqw33yEilxogJvwA=="],
-
-    "opentui-spinner/@opentui/solid/@babel/core": ["@babel/core@7.28.0", "", { "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.0", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.27.3", "@babel/helpers": "^7.27.6", "@babel/parser": "^7.28.0", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.0", "@babel/types": "^7.28.0", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-UlLAnTPrFdNGoFtbSXwcGFQBtQZJCNjaN6hQNP3UPvuNXT1i82N26KL3dZeIpNalWywr9IuQuncaAfUaS1g6sQ=="],
-
-    "opentui-spinner/@opentui/solid/babel-preset-solid": ["babel-preset-solid@1.9.10", "", { "dependencies": { "babel-plugin-jsx-dom-expressions": "^0.40.3" }, "peerDependencies": { "@babel/core": "^7.0.0", "solid-js": "^1.9.10" }, "optionalPeers": ["solid-js"] }, "sha512-HCelrgua/Y+kqO8RyL04JBWS/cVdrtUv/h45GntgQY+cJl4eBcKkCDV3TdMjtKx1nXwRaR9QXslM/Npm1dxdZQ=="],
-
    "ora/bl/buffer": ["buffer@5.7.1", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" } }, "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ=="],

    "ora/bl/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
@@ -7073,18 +7053,6 @@

    "opencontrol/@modelcontextprotocol/sdk/express/type-is": ["type-is@2.0.1", "", { "dependencies": { "content-type": "^1.0.5", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw=="],

-    "opentui-spinner/@opentui/core/bun-webgpu/@webgpu/types": ["@webgpu/types@0.1.69", "", {}, "sha512-RPmm6kgRbI8e98zSD3RVACvnuktIja5+yLgDAkTmxLr90BEwdTXRQWNLF3ETTTyH/8mKhznZuN5AveXYFEsMGQ=="],
-
-    "opentui-spinner/@opentui/core/bun-webgpu/bun-webgpu-darwin-arm64": ["bun-webgpu-darwin-arm64@0.1.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-lIsDkPzJzPl6yrB5CUOINJFPnTRv6fF/Q8J1mAr43ogSp86WZEg9XZKaT6f3EUJ+9ETogGoMnoj1q0AwHUTbAQ=="],
-
-    "opentui-spinner/@opentui/core/bun-webgpu/bun-webgpu-darwin-x64": ["bun-webgpu-darwin-x64@0.1.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-uEddf5U7GvKIkM/BV18rUKtYHL6d0KeqBjNHwfqDH9QgEo9KVSKvJXS5I/sMefk5V5pIYE+8tQhtrREevhocng=="],
-
-    "opentui-spinner/@opentui/core/bun-webgpu/bun-webgpu-linux-x64": ["bun-webgpu-linux-x64@0.1.6", "", { "os": "linux", "cpu": "x64" }, "sha512-Y/f15j9r8ba0xUz+3lATtS74OE+PPzQXO7Do/1eCluJcuOlfa77kMjvBK/ShWnem3Y9xqi59pebTPOGRB+CaJA=="],
-
-    "opentui-spinner/@opentui/core/bun-webgpu/bun-webgpu-win32-x64": ["bun-webgpu-win32-x64@0.1.6", "", { "os": "win32", "cpu": "x64" }, "sha512-MHSFAKqizISb+C5NfDrFe3g0Al5Njnu0j/A+oO2Q+bIWX+fUYjBSowiYE1ZXJx65KuryuB+tiM7Qh6cQbVvkEg=="],
-
-    "opentui-spinner/@opentui/solid/@babel/core/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
-
    "ora/bl/buffer/ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],

    "pkg-up/find-up/locate-path/p-locate": ["p-locate@3.0.0", "", { "dependencies": { "p-limit": "^2.0.0" } }, "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ=="],
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-cBfg4pJ4mjsfS4MFFASBaZZykArgIoeo/3woOcSGy1U=",
-    "aarch64-linux": "sha256-Q6cqUwfqbscdrPW0uHcfshhQINjJi0HiyURMSdOOCf4=",
-    "aarch64-darwin": "sha256-1AtfsD1D9YxWSEsecPJF9XsvsxsWTtVtkP5l6UW43og=",
-    "x86_64-darwin": "sha256-YS5/8YTf9LymAUbjXVrGDfxtKVJrpZbPnnCtsGHSHoU="
+    "x86_64-linux": "sha256-h2T/LnUnISZZDn9ZQkZ/A59P+6+QdfOlrgl4RXK/vgM=",
+    "aarch64-linux": "sha256-+DRohG1ZEB/2LtZU90GWoqJkeyu/sW8A8oKT3f/TtQ0=",
+    "aarch64-darwin": "sha256-k4nsk/WduuxY8HgjRuqzGT9EjEo7V/2mAzBTYee0fZ0=",
+    "x86_64-darwin": "sha256-3dSvfN2+5lXwOx57x8NSIWbEZ1fp6+1T6bJpAuUNPyk="
  }
 }
@@ -34,8 +34,8 @@
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.2.0",
-      "@opentui/solid": "0.2.0",
+      "@opentui/core": "0.1.105",
+      "@opentui/solid": "0.1.105",
      "ulid": "3.0.1",
      "@kobalte/core": "0.13.11",
      "@types/luxon": "3.7.1",
@@ -187,7 +187,7 @@ export function createChildStoreManager(input: {
            projectMeta: initialMeta,
            icon: initialIcon,
            get provider_ready() {
-              return !providerQuery.isLoading
+              return providerQuery.isLoading
            },
            provider: { all: [], connected: [], default: {} },
            config: {},
@@ -207,13 +207,13 @@ export function createChildStoreManager(input: {
            permission: {},
            question: {},
            get mcp_ready() {
-              return !mcpQuery.isLoading
+              return mcpQuery.isLoading
            },
            get mcp() {
              return mcpQuery.isLoading ? {} : (mcpQuery.data ?? {})
            },
            get lsp_ready() {
-              return !lspQuery.isLoading
+              return lspQuery.isLoading
            },
            get lsp() {
              return lspQuery.isLoading ? [] : (lspQuery.data ?? [])
@@ -382,7 +382,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
          setSaved("session", session, {
            agent: msg.agent,
            model: msg.model,
-            variant: msg.model?.variant ?? null,
+            variant: msg.model.variant ?? null,
          })
        },
      },
@@ -47,7 +47,7 @@ export const Flag = {
  OPENCODE_DISABLE_CLAUDE_CODE,
  OPENCODE_DISABLE_CLAUDE_CODE_PROMPT: OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT"),
  OPENCODE_DISABLE_CLAUDE_CODE_SKILLS,
-  OPENCODE_DISABLE_EXTERNAL_SKILLS: truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS"),
+  OPENCODE_DISABLE_EXTERNAL_SKILLS: OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS"),
  OPENCODE_FAKE_VCS: process.env["OPENCODE_FAKE_VCS"],
  OPENCODE_SERVER_PASSWORD: process.env["OPENCODE_SERVER_PASSWORD"],
  OPENCODE_SERVER_USERNAME: process.env["OPENCODE_SERVER_USERNAME"],
@@ -4,7 +4,6 @@ import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
 import os from "os"
 import { Context, Effect, Layer } from "effect"
 import { Flock } from "./util/flock"
-import { Flag } from "./flag/flag"

 const app = "opencode"
 const data = path.join(xdgData!, app)
@@ -48,28 +47,19 @@ export interface Interface {
  readonly log: string
 }

-export function make(input: Partial<Interface> = {}): Interface {
-  return {
-    home: Path.home,
-    data: Path.data,
-    cache: Path.cache,
-    config: Flag.OPENCODE_CONFIG_DIR ?? Path.config,
-    state: Path.state,
-    bin: Path.bin,
-    log: Path.log,
-    ...input,
-  }
-}
-
 export const layer = Layer.effect(
  Service,
-  Effect.sync(() => Service.of(make())),
+  Effect.gen(function* () {
+    return Service.of({
+      home: Path.home,
+      data: Path.data,
+      cache: Path.cache,
+      config: Path.config,
+      state: Path.state,
+      bin: Path.bin,
+      log: Path.log,
+    })
+  }),
 )

-export const layerWith = (input: Partial<Interface>) =>
-  Layer.effect(
-    Service,
-    Effect.sync(() => Service.of(make(input))),
-  )
-
 export * as Global from "./global"
@@ -18,17 +18,20 @@ function sleep(ms: number) {
  return new Promise<void>((resolve) => setTimeout(resolve, ms))
 }

-const msg: Msg = JSON.parse(process.argv[2])
+const msg: Msg = JSON.parse(process.argv[2]!)

-const testGlobal = Global.layerWith({
-  home: os.homedir(),
-  data: os.tmpdir(),
-  cache: os.tmpdir(),
-  config: os.tmpdir(),
-  state: os.tmpdir(),
-  bin: os.tmpdir(),
-  log: os.tmpdir(),
-})
+const testGlobal = Layer.succeed(
+  Global.Service,
+  Global.Service.of({
+    home: os.homedir(),
+    data: os.tmpdir(),
+    cache: os.tmpdir(),
+    config: os.tmpdir(),
+    state: os.tmpdir(),
+    bin: os.tmpdir(),
+    log: os.tmpdir(),
+  }),
+)

 const testLayer = EffectFlock.layer.pipe(Layer.provide(testGlobal), Layer.provide(AppFileSystem.defaultLayer))

@@ -93,15 +93,18 @@ async function waitForFile(file: string, timeout = 3_000) {
 // Test layer
 // ---------------------------------------------------------------------------

-const testGlobal = Global.layerWith({
-  home: os.homedir(),
-  data: os.tmpdir(),
-  cache: os.tmpdir(),
-  config: os.tmpdir(),
-  state: os.tmpdir(),
-  bin: os.tmpdir(),
-  log: os.tmpdir(),
-})
+const testGlobal = Layer.succeed(
+  Global.Service,
+  Global.Service.of({
+    home: os.homedir(),
+    data: os.tmpdir(),
+    cache: os.tmpdir(),
+    config: os.tmpdir(),
+    state: os.tmpdir(),
+    bin: os.tmpdir(),
+    log: os.tmpdir(),
+  }),
+)

 const testLayer = EffectFlock.layer.pipe(Layer.provide(testGlobal), Layer.provide(AppFileSystem.defaultLayer))

@@ -50,7 +50,6 @@ console.log(`Loaded ${migrations.length} migrations`)
 const singleFlag = process.argv.includes("--single")
 const baselineFlag = process.argv.includes("--baseline")
 const skipInstall = process.argv.includes("--skip-install")
-const sourcemapsFlag = process.argv.includes("--sourcemaps")
 const plugin = createSolidTransformPlugin()
 const skipEmbedWebUi = process.argv.includes("--skip-embed-web-ui")

@@ -200,7 +199,6 @@ for (const item of targets) {
    external: ["node-gyp"],
    format: "esm",
    minify: true,
-    sourcemap: sourcemapsFlag ? "linked" : "none",
    splitting: true,
    compile: {
      autoloadBunfig: false,
@@ -12,16 +12,14 @@ Plan for replacing instance Hono route implementations with Effect `HttpApi` whi

 ## Current State

- `OPENCODE_EXPERIMENTAL_HTTPAPI` selects the backend at server startup. Default is still `hono`.
- `server/backend.ts` picks one of `effect-httpapi` or `hono`; `server.ts` builds either a pure Effect `HttpApi` web handler or the legacy Hono app accordingly. The earlier in-Hono "bridge" model has been replaced by this fork-at-startup.
- Legacy Hono routes remain mounted for the `hono` backend and remain the source for `hono-openapi` SDK generation.
- An Effect `HttpApi` OpenAPI surface exists (`OpenApi.fromApi(PublicApi)` in `cli/cmd/generate.ts --httpapi`, `OPENCODE_SDK_OPENAPI=httpapi` in `packages/sdk/js/script/build.ts`) but is opt-in. The default SDK generation is still Hono.
- `httpapi/public.ts` carries the Hono-compat normalization for the Effect-generated OpenAPI surface (auth scheme strip, request-body required flag, optional `null` arms, `BadRequestError` / `NotFoundError` remap, `$ref` self-cycle fix, `auth_token` query injection). Today's Effect-generated SDK is not byte-identical to the Hono-generated SDK — see Phase 4.
- Auth is centrally configured for the Effect backend via Effect `Config` (`refactor: use Effect config for HttpApi authorization`, `Fix HttpApi raw route authorization`) rather than re-attached in each route module.
+- `OPENCODE_EXPERIMENTAL_HTTPAPI` gates the bridge. Default behavior still uses Hono.
+- The bridge mounts selected paths in `server/routes/instance/index.ts` before legacy Hono routes.
+- Legacy Hono routes remain for default behavior and for `hono-openapi` SDK generation.
+- `HttpApi` auth is independent of Hono auth.
+- `Authorization` is attached in each route module, not centrally wrapped in `server.ts`.
 - Auth supports Basic auth and the legacy `auth_token` query parameter through `HttpApiSecurity.apiKey`.
 - Instance context is provided by `httpapi/server.ts` using `directory`, `workspace`, and `x-opencode-directory`.
 - `Observability.layer` is provided in the Effect route layer and deduplicated through the shared `memoMap`.
- CORS middleware is wired into both backends (`feat(httpapi): add CORS middleware to instance routes`).

 ## Migration Rules

@@ -124,19 +122,10 @@ Keep large or stateful groups for later:

 Hono routes cannot be deleted while `hono-openapi` is the source of SDK generation.

-Status: the Effect `HttpApi` OpenAPI surface is **implemented and opt-in** (`bun dev generate --httpapi`, `OPENCODE_SDK_OPENAPI=httpapi`). Default SDK generation still uses Hono. `httpapi/public.ts` applies the Hono-compat normalization layer to the Effect output. Diff against the Hono-generated spec still shows real gaps that must be closed before the SDK can flip:
-
- Branded-type `pattern` constraints on ID schemas are not propagated to the Effect output (~169 missing).
- Per-property `description` annotations are not propagated through `Schema.Struct` to the Effect output (~107 missing).
- `Event.*` and `SyncEvent.*` component names use dotted form in Hono and PascalCase in Effect (~50 differences, breaks SDK type names).
- Effect's component deduper emits numbered duplicates (`Session9`, `SyncEvent.session.updated.11`) that need a name-collision fix.
- Cosmetic-only diffs (`additionalProperties: false`, `const` vs `enum`, MAX_SAFE_INTEGER `maximum`, `propertyNames`) can be normalized in `public.ts` if they would otherwise change SDK output.
-
 Required before route deletion:

- Close the diff above so Effect-generated SDK output matches the Hono-generated SDK output for every retained path.
+- Generate the public OpenAPI surface from Effect `HttpApi` for ported routes.
 - Keep operation IDs, schemas, status codes, and SDK type names stable unless the change is intentional.
- Flip `packages/sdk/js/script/build.ts` default to `httpapi` and regenerate.
 - Compare generated SDK output against `dev` for every route group deletion.
 - Remove Hono OpenAPI stubs only after Effect OpenAPI is the SDK source for those paths.

@@ -198,7 +187,7 @@ Use raw Effect HTTP routes where `HttpApi` does not fit. The goal is deleting Ho
 | `project`                 | `bridged`         | list, current, git init, update                                            |
 | `file`                    | `bridged` partial | find text/file/symbol, list/content/status                                 |
 | `mcp`                     | `bridged`         | status, add, OAuth, connect/disconnect                                     |
-| `workspace`               | `bridged`         | adaptor/list/status/create/remove/session-restore                          |
+| `workspace`               | `bridged`         | adapter/list/status/create/remove/session-restore                          |
 | top-level instance routes | `bridged`         | path, vcs, command, agent, skill, lsp, formatter, dispose                  |
 | experimental JSON routes  | `bridged`         | console, tool, worktree list/mutations, global session list, resource list |
 | `session`                 | `bridged`         | read, lifecycle, prompt, message/part mutations, revert, permission reply  |
@@ -290,7 +279,7 @@ This checklist tracks bridge parity only. Checked routes are available through t

 ### Workspace Routes

- [x] `GET /experimental/workspace/adaptor` - list workspace adaptors.
+- [x] `GET /experimental/workspace/adapter` - list workspace adapters.
 - [x] `POST /experimental/workspace` - create workspace.
 - [x] `GET /experimental/workspace` - list workspaces.
 - [x] `GET /experimental/workspace/status` - workspace status.
@@ -376,26 +365,25 @@ Prefer smaller PRs from here so route behavior and SDK/OpenAPI fallout stays rev
 8. [x] Bridge session read routes: list, status, get, children, todo, diff, messages.
 9. [x] Bridge session lifecycle mutation routes: create, delete, update, fork, abort.
 10. [x] Bridge remaining session mutation and prompt routes.
-11. [ ] Replace event SSE with non-Hono Effect HTTP. The Effect backend has a raw Effect HTTP `httpapi/event.ts`; the Hono backend still uses `hono/streaming` `streamSSE`. Either port Hono `/event` to raw Effect HTTP for the fallback window, or skip and delete it together with Hono in step 15.
-12. [x] Replace pty websocket/control routes with non-Hono Effect HTTP for the Effect backend. Hono `pty.ts` remains in the Hono backend.
-13. [x] Replace tui bridge routes or explicitly isolate them behind a non-Hono compatibility layer for the Effect backend. Hono `tui.ts` remains in the Hono backend.
-14. [ ] Switch OpenAPI/SDK generation to Effect routes and compare SDK output. Effect path is implemented and opt-in via `--httpapi` / `OPENCODE_SDK_OPENAPI=httpapi`. Close the schema-shape gaps in `public.ts` (branded `pattern`, per-property `description`, `Event.*` / `SyncEvent.*` naming, dedup collisions), then flip `packages/sdk/js/script/build.ts` default.
-15. [ ] Flip `backend.ts` default from `hono` to `effect-httpapi`, keep `OPENCODE_EXPERIMENTAL_HTTPAPI` (or its inverse) as a short fallback flag, then delete replaced Hono route files.
+11. [ ] Replace event SSE with non-Hono Effect HTTP.
+12. [x] Replace pty websocket/control routes with non-Hono Effect HTTP.
+13. [x] Replace tui bridge routes or explicitly isolate them behind a non-Hono compatibility layer.
+14. [ ] Switch OpenAPI/SDK generation to Effect routes and compare SDK output.
+15. [ ] Flip ported JSON routes default-on, keep a short fallback, then delete replaced Hono route files.

 ## Checklist

 - [x] Add first `HttpApi` JSON route slices.
- [x] Bridge selected `HttpApi` routes behind `OPENCODE_EXPERIMENTAL_HTTPAPI`. (Now backend-fork-at-startup rather than in-Hono path mounting.)
+- [x] Bridge selected `HttpApi` routes into Hono behind `OPENCODE_EXPERIMENTAL_HTTPAPI`.
 - [x] Reuse existing Effect services in handlers.
 - [x] Provide auth, instance lookup, and observability in the Effect route layer.
- [x] Centralize auth via Effect `Config` for the Effect backend.
+- [x] Attach auth middleware in route modules.
 - [x] Support `auth_token` as a query security scheme.
 - [x] Add bridge-level auth and instance tests.
 - [x] Complete exact Hono route inventory.
 - [x] Resolve implemented-but-unmounted route groups.
 - [x] Port remaining top-level JSON reads.
- [x] Implement Effect `HttpApi` OpenAPI generation behind `--httpapi` / `OPENCODE_SDK_OPENAPI=httpapi`.
- [ ] Close Effect-vs-Hono OpenAPI schema-shape gaps and flip the SDK generator default.
- [ ] Flip the runtime backend default from `hono` to `effect-httpapi`, with a short fallback flag.
+- [ ] Generate SDK/OpenAPI from Effect routes.
+- [ ] Flip ported JSON routes to default-on with fallback.
 - [ ] Delete replaced Hono route implementations.
- [ ] Replace SSE/websocket/streaming Hono routes with non-Hono implementations (or remove with the rest of Hono).
+- [ ] Replace SSE/websocket/streaming Hono routes with non-Hono implementations.
@@ -353,7 +353,7 @@ piecewise.
 - [ ] `src/cli/cmd/tui/event.ts`
 - [ ] `src/cli/ui.ts`
 - [ ] `src/command/index.ts`
- [x] `src/control-plane/adaptors/worktree.ts`
+- [x] `src/control-plane/adapters/worktree.ts`
 - [x] `src/control-plane/types.ts`
 - [x] `src/control-plane/workspace.ts`
 - [ ] `src/file/index.ts`
@@ -156,38 +156,28 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
  }

  if (method.type === "api") {
-    const key = await prompts.password({
-      message: "Enter your API key",
-      validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-    })
-    if (prompts.isCancel(key)) throw new UI.CancelledError()
-
-    const metadata = Object.keys(inputs).length ? { metadata: inputs } : {}
-    if (!method.authorize) {
-      await put(provider, {
-        type: "api",
-        key,
-        ...metadata,
+    if (method.authorize) {
+      const key = await prompts.password({
+        message: "Enter your API key",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
      })
+      if (prompts.isCancel(key)) throw new UI.CancelledError()
+
+      const result = await method.authorize(inputs)
+      if (result.type === "failed") {
+        prompts.log.error("Failed to authorize")
+      }
+      if (result.type === "success") {
+        const saveProvider = result.provider ?? provider
+        await put(saveProvider, {
+          type: "api",
+          key: result.key ?? key,
+        })
+        prompts.log.success("Login successful")
+      }
      prompts.outro("Done")
      return true
    }
-
-    const result = await method.authorize(inputs)
-    if (result.type === "failed") {
-      prompts.log.error("Failed to authorize")
-    }
-    if (result.type === "success") {
-      const saveProvider = result.provider ?? provider
-      await put(saveProvider, {
-        type: "api",
-        key: result.key ?? key,
-        ...metadata,
-      })
-      prompts.log.success("Login successful")
-    }
-    prompts.outro("Done")
-    return true
  }

  return false
@@ -10,7 +10,7 @@ import { errorMessage } from "@/util/error"
 import { useSDK } from "../context/sdk"
 import { useToast } from "../ui/toast"

-type Adaptor = {
+type Adapter = {
  type: string
  name: string
  description: string
@@ -108,26 +108,26 @@ export function DialogWorkspaceCreate(props: { onSelect: (workspaceID: string) =
  const sdk = useSDK()
  const toast = useToast()
  const [creating, setCreating] = createSignal<string>()
-  const [adaptors, setAdaptors] = createSignal<Adaptor[]>()
+  const [adapters, setAdapters] = createSignal<Adapter[]>()

  onMount(() => {
    dialog.setSize("medium")
    void (async () => {
      const dir = sync.path.directory || sdk.directory
-      const url = new URL("/experimental/workspace/adaptor", sdk.url)
+      const url = new URL("/experimental/workspace/adapter", sdk.url)
      if (dir) url.searchParams.set("directory", dir)
      const res = await sdk
        .fetch(url)
-        .then((x) => x.json() as Promise<Adaptor[]>)
+        .then((x) => x.json() as Promise<Adapter[]>)
        .catch(() => undefined)
      if (!res) {
        toast.show({
-          message: "Failed to load workspace adaptors",
+          message: "Failed to load workspace adapters",
          variant: "error",
        })
        return
      }
-      setAdaptors(res)
+      setAdapters(res)
    })()
  })

@@ -142,13 +142,13 @@ export function DialogWorkspaceCreate(props: { onSelect: (workspaceID: string) =
        },
      ]
    }
-    const list = adaptors()
+    const list = adapters()
    if (!list) {
      return [
        {
          title: "Loading workspaces...",
          value: "loading" as const,
-          description: "Fetching available workspace adaptors",
+          description: "Fetching available workspace adapters",
        },
      ]
    }
@@ -12,7 +12,7 @@ import { useRoute } from "@tui/context/route"
 import { useProject } from "@tui/context/project"
 import { useSync } from "@tui/context/sync"
 import { useEvent } from "@tui/context/event"
-import { editorSelectionKey, useEditorContext, type EditorSelection } from "@tui/context/editor"
+import { useEditorContext, type EditorSelection } from "@tui/context/editor"
 import { MessageID, PartID } from "@/session/schema"
 import { createStore, produce, unwrap } from "solid-js/store"
 import { useKeybind } from "@tui/context/keybind"
@@ -84,30 +84,16 @@ function fadeColor(color: RGBA, alpha: number) {
  return RGBA.fromValues(color.r, color.g, color.b, color.a * alpha)
 }

-function hasEditorRangeSelection(selection: EditorSelection["ranges"][number]) {
-  return (
-    selection.selection.start.line !== selection.selection.end.line ||
-    selection.selection.start.character !== selection.selection.end.character
-  )
-}
-
-function getEditorRangeLabel(selection: EditorSelection["ranges"][number]) {
-  if (!hasEditorRangeSelection(selection)) return
-  if (selection.selection.start.line === selection.selection.end.line) return `#${selection.selection.start.line}`
-  return `#${selection.selection.start.line}-${selection.selection.end.line}`
-}
-
-function formatEditorContext(selection: EditorSelection) {
-  const selected = selection.ranges.filter(hasEditorRangeSelection)
-  if (selected.length === 0)
-    return `<system-reminder>Note: The user opened the file "${selection.filePath}". This may or may not be relevant to the current task.</system-reminder>\n`
-
-  const ranges = selected.map((range, index) => {
-    const prefix = selected.length > 1 ? `Selection ${index + 1}: ` : ""
-    return `Note: The user selected ${prefix}${getEditorRangeLabel(range)} from "${selection.filePath}". \`\`\`${range.text}\`\`\`\n\n`
-  })
-
-  return `<system-reminder>${ranges.join("\n")} This may or may not be relevant to the current task.</system-reminder>\n`
+function getEditorSelectionKey(selection: EditorSelection) {
+  return [
+    selection.filePath,
+    selection.text,
+    selection.source ?? "",
+    selection.selection.start.line,
+    selection.selection.start.character,
+    selection.selection.end.line,
+    selection.selection.end.character,
+  ].join("-")
 }

 let stashed: { prompt: PromptInfo; cursor: number } | undefined
@@ -139,21 +125,13 @@ export function Prompt(props: PromptProps) {
  const list = createMemo(() => props.placeholders?.normal ?? [])
  const shell = createMemo(() => props.placeholders?.shell ?? [])
  const fileContextEnabled = createMemo(() => kv.get("file_context_enabled", true))
-  const [dismissedEditorSelectionKey, setDismissedEditorSelectionKey] = createSignal<string>()
-  const editorContext = createMemo(() => {
-    const selection = fileContextEnabled() ? editor.selection() : undefined
-    if (!selection) return
-    return editorSelectionKey(selection) === dismissedEditorSelectionKey() ? undefined : selection
-  })
-  const editorPath = createMemo(() => editorContext()?.filePath)
+  const editorPath = createMemo(() => (fileContextEnabled() ? editor.selection()?.filePath : undefined))
  const editorSelectionLabel = createMemo(() => {
-    const ranges = editorContext()?.ranges
-    if (!ranges) return
-    const first = ranges.find(hasEditorRangeSelection) ?? ranges[0]
-    if (!first) return
-    return [getEditorRangeLabel(first), ranges.length > 1 ? `+${ranges.length - 1}` : undefined]
-      .filter(Boolean)
-      .join(" ")
+    const selection = fileContextEnabled() ? editor.selection()?.selection : undefined
+    if (!selection) return
+    if (selection.start.line === selection.end.line && selection.start.character === selection.end.character) return
+    if (selection.start.line === selection.end.line) return `#${selection.start.line}`
+    return `#${selection.start.line}-${selection.end.line}`
  })
  const editorFileLabel = createMemo(() => {
    const value = editorPath()
@@ -169,7 +147,6 @@ export function Prompt(props: PromptProps) {
    if (!file) return
    return Locale.truncateMiddle(file, Math.max(12, Math.min(48, Math.floor(dimensions().width / 3))))
  })
-  const [editorContextHover, setEditorContextHover] = createSignal(false)
  let lastSubmittedEditorSelectionKey: string | undefined
  const [auto, setAuto] = createSignal<AutocompleteRef>()
  const currentProviderLabel = createMemo(() => local.model.parsed().provider)
@@ -186,11 +163,6 @@ export function Prompt(props: PromptProps) {
    }
  }

-  function dismissEditorContext() {
-    setDismissedEditorSelectionKey(editorSelectionKey(editorContext()))
-    editor.clearSelection()
-  }
-
  const textareaKeybindings = useTextareaKeybindings()

  const fileStyleId = syntax().getStyleId("extmark.file")!
@@ -320,16 +292,6 @@ export function Prompt(props: PromptProps) {
          dialog.clear()
        },
      },
-      {
-        title: "Remove editor context",
-        value: "prompt.editor_context.clear",
-        category: "Prompt",
-        enabled: Boolean(editorContext()),
-        onSelect: (dialog) => {
-          dismissEditorContext()
-          dialog.clear()
-        },
-      },
      {
        title: "Paste",
        value: "prompt.paste",
@@ -798,21 +760,35 @@ export function Prompt(props: PromptProps) {
    // Capture mode before it gets reset
    const currentMode = store.mode
    const variant = local.model.variant.current()
-    const editorSelection = editorContext()
-    const currentEditorSelectionKey = editorSelectionKey(editorSelection)
+    const editorSelection = fileContextEnabled() ? editor.selection() : undefined
+    const editorSelectionKey = editorSelection ? getEditorSelectionKey(editorSelection) : undefined
    const editorParts =
-      editorSelection && currentEditorSelectionKey !== lastSubmittedEditorSelectionKey
+      editorSelection && editorSelectionKey !== lastSubmittedEditorSelectionKey
        ? [
            {
              id: PartID.ascending(),
              type: "text" as const,
-              text: formatEditorContext(editorSelection),
+              text: (() => {
+                const start = editorSelection.selection.start
+                const end = editorSelection.selection.end
+
+                let text = ""
+                if (start.line === end.line && start.character === end.character) {
+                  text = `Note: The user opened the file "${editorSelection.filePath}".`
+                } else if (start.line === end.line) {
+                  text = `Note: The user selected line ${start.line + 1} from "${editorSelection.filePath}". \`\`\`${editorSelection.text}\`\`\`\n\n`
+                } else {
+                  text = `Note: The user selected lines ${start.line + 1} to ${end.line + 1} from "${editorSelection.filePath}". \`\`\`${editorSelection.text}\`\`\`\n\n`
+                }
+
+                return `<system-reminder>${text} This may or may not be relevant to the current task.</system-reminder>\n`
+              })(),
              synthetic: true,
              metadata: {
                kind: "editor_context",
                source: editorSelection.source ?? "editor",
                filePath: editorSelection.filePath,
-                ranges: editorSelection.ranges,
+                selection: editorSelection.selection,
              },
            },
          ]
@@ -879,7 +855,7 @@ export function Prompt(props: PromptProps) {
          ],
        })
        .catch(() => {})
-      lastSubmittedEditorSelectionKey = currentEditorSelectionKey
+      lastSubmittedEditorSelectionKey = editorSelectionKey
    }
    history.append({
      ...store.prompt,
@@ -1430,18 +1406,7 @@ export function Prompt(props: PromptProps) {
          </Show>
          <Show when={status().type !== "retry"}>
            <box gap={2} flexDirection="row">
-              <Show when={editorFileLabelDisplay()}>
-                {(file) => (
-                  <text
-                    fg={theme.secondary}
-                    onMouseOver={() => setEditorContextHover(true)}
-                    onMouseOut={() => setEditorContextHover(false)}
-                    onMouseUp={dismissEditorContext}
-                  >
-                    {editorContextHover() ? `x ${file()}` : file()}
-                  </text>
-                )}
-              </Show>
+              <Show when={editorFileLabelDisplay()}>{(file) => <text fg={theme.secondary}>{file()}</text>}</Show>
              <Switch>
                <Match when={store.mode === "normal"}>
                  <Switch>
@@ -12,9 +12,6 @@ const ZedEditorRowSchema = z.object({
  workspace_paths: z.string().nullable(),
  timestamp: z.string(),
  buffer_path: z.string().nullable(),
-})
-
-const ZedSelectionRowSchema = z.object({
  selection_start: z.number().nullable(),
  selection_end: z.number().nullable(),
 })
@@ -27,7 +24,6 @@ const utf8 = new TextEncoder()

 type ZedEditorRow = z.infer<typeof ZedEditorRowSchema>
 type ZedActiveEditorRow = ZedEditorRow & { item_kind: "Editor"; editor_id: number }
-type ZedSelectionRow = z.infer<typeof ZedSelectionRowSchema>

 export type ZedSelectionResult =
  | { type: "selection"; selection: EditorSelection }
@@ -40,21 +36,7 @@ export async function resolveZedSelection(dbPath: string, cwd = process.cwd()):

  const row = active.row
  if (!row.buffer_path) return { type: "empty" }
-
-  const selections = queryZedEditorSelections(dbPath, row)
-  if (selections.type !== "selections") return selections
-  const byteRanges = selections.selections
-    .flatMap((selection) => {
-      if (selection.selection_start == null || selection.selection_end == null) return []
-      return [
-        {
-          start: Math.min(selection.selection_start, selection.selection_end),
-          end: Math.max(selection.selection_start, selection.selection_end),
-        },
-      ]
-    })
-    .sort((left, right) => left.start - right.start || left.end - right.end)
-  if (byteRanges.length === 0) return { type: "unavailable" }
+  if (row.selection_start == null || row.selection_end == null) return { type: "unavailable" }

  const contents = queryZedEditorContents(dbPath, row)
  const text =
@@ -65,21 +47,16 @@ export async function resolveZedSelection(dbPath: string, cwd = process.cwd()):
          .catch(() => undefined)
  if (text == null) return { type: "unavailable" }

-  const ranges = byteRanges.map((range) => {
-    const startOffset = utf8ByteOffsetToStringIndex(text, range.start)
-    const endOffset = utf8ByteOffsetToStringIndex(text, range.end)
-    return {
-      text: text.slice(startOffset, endOffset),
-      selection: offsetsToSelection(text, startOffset, endOffset),
-    }
-  })
+  const startOffset = utf8ByteOffsetToStringIndex(text, Math.min(row.selection_start, row.selection_end))
+  const endOffset = utf8ByteOffsetToStringIndex(text, Math.max(row.selection_start, row.selection_end))

  return {
    type: "selection",
    selection: {
+      text: text.slice(startOffset, endOffset),
      filePath: row.buffer_path,
      source: "zed",
-      ranges,
+      selection: offsetsToSelection(text, startOffset, endOffset),
    },
  }
 }
@@ -96,11 +73,14 @@ function queryZedActiveEditor(dbPath: string, cwd: string) {
          i.workspace_id as workspace_id,
          w.paths as workspace_paths,
          w.timestamp as timestamp,
-          e.buffer_path as buffer_path
+          e.buffer_path as buffer_path,
+          s.start as selection_start,
+          s.end as selection_end
        from items i
        join panes p on p.pane_id = i.pane_id and p.workspace_id = i.workspace_id
        join workspaces w on w.workspace_id = i.workspace_id
        left join editors e on e.item_id = i.item_id and e.workspace_id = i.workspace_id
+        left join editor_selections s on s.editor_id = e.item_id and s.workspace_id = e.workspace_id
        where i.active = 1 and p.active = 1
        order by w.timestamp desc`,
      )
@@ -128,34 +108,6 @@ function queryZedActiveEditor(dbPath: string, cwd: string) {
  }
 }

-function queryZedEditorSelections(dbPath: string, row: ZedActiveEditorRow) {
-  let db: Database | undefined
-  try {
-    db = new Database(dbPath, { readonly: true })
-    const raw = db
-      .query(
-        `select
-          start as selection_start,
-          end as selection_end
-        from editor_selections
-        where editor_id = $editorID and workspace_id = $workspaceID`,
-      )
-      .all({ $editorID: row.editor_id, $workspaceID: row.workspace_id })
-
-    const selections = raw.flatMap((selection) => {
-      const parsed = ZedSelectionRowSchema.safeParse(selection)
-      return parsed.success ? [parsed.data] : []
-    })
-
-    if (raw.length > 0 && selections.length === 0) return { type: "unavailable" as const }
-    return { type: "selections" as const, selections }
-  } catch {
-    return { type: "unavailable" as const }
-  } finally {
-    db?.close()
-  }
-}
-
 function queryZedEditorContents(dbPath: string, row: ZedActiveEditorRow) {
  let db: Database | undefined
  try {
@@ -28,46 +28,16 @@ const PositionSchema = z.object({
  character: z.number(),
 })

-const EditorSelectionRangeSchema = z.object({
+const EditorSelectionSchema = z.object({
  text: z.string(),
+  filePath: z.string(),
+  source: z.enum(["websocket", "zed"]).optional(),
  selection: z.object({
    start: PositionSchema,
    end: PositionSchema,
  }),
 })

-const EditorSelectionSchema = z
-  .union([
-    z.object({
-      filePath: z.string(),
-      source: z.enum(["websocket", "zed"]).optional(),
-      ranges: z.array(EditorSelectionRangeSchema).min(1),
-    }),
-    z.object({
-      text: z.string(),
-      filePath: z.string(),
-      source: z.enum(["websocket", "zed"]).optional(),
-      selection: z.object({
-        start: PositionSchema,
-        end: PositionSchema,
-      }),
-    }),
-  ])
-  .transform((value) =>
-    "ranges" in value
-      ? value
-      : {
-          filePath: value.filePath,
-          source: value.source,
-          ranges: [
-            {
-              text: value.text,
-              selection: value.selection,
-            },
-          ],
-        },
-  )
-
 const EditorMentionSchema = z.object({
  filePath: z.string(),
  lineStart: z.number(),
@@ -292,7 +262,6 @@ export const { use: useEditorContext, provider: EditorContextProvider } = create
        return store.selection
      },
      clearSelection() {
-        lastZedSelectionKey = undefined
        setStore("selection", undefined)
      },
      onMention(listener: (mention: EditorMention) => void) {
@@ -383,17 +352,15 @@ function readEditorLockFile(filePath: string): EditorLockFile | undefined {
  }
 }

-export function editorSelectionKey(selection: EditorSelection | undefined) {
+function editorSelectionKey(selection: EditorSelection | undefined) {
  if (!selection) return ""
  return [
    selection.filePath,
-    ...selection.ranges.flatMap((range) => [
-      range.selection.start.line,
-      range.selection.start.character,
-      range.selection.end.line,
-      range.selection.end.character,
-      range.text,
-    ]),
+    selection.selection.start.line,
+    selection.selection.start.character,
+    selection.selection.end.line,
+    selection.selection.end.character,
+    selection.text,
  ].join("\0")
 }

@@ -71,12 +71,6 @@ async function input(value?: string) {
  return piped + "\n" + value
 }

-export function resolveThreadDirectory(project?: string, envPWD = process.env.PWD, cwd = process.cwd()) {
-  const root = Filesystem.resolve(envPWD ?? cwd)
-  if (project) return Filesystem.resolve(path.isAbsolute(project) ? project : path.join(root, project))
-  return Filesystem.resolve(cwd)
-}
-
 export const TuiThreadCommand = cmd({
  command: "$0 [project]",
  describe: "start opencode tui",
@@ -130,7 +124,10 @@ export const TuiThreadCommand = cmd({

      // Resolve relative --project paths from PWD, then use the real cwd after
      // chdir so the thread and worker share the same directory key.
-      const next = resolveThreadDirectory(args.project)
+      const root = Filesystem.resolve(process.env.PWD ?? process.cwd())
+      const next = args.project
+        ? Filesystem.resolve(path.isAbsolute(args.project) ? args.project : path.join(root, args.project))
+        : Filesystem.resolve(process.cwd())
      const file = await target()
      try {
        process.chdir(next)
@@ -0,0 +1,46 @@
+import { lazy } from "@/util/lazy"
+import type { ProjectID } from "@/project/schema"
+import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
+
+const BUILTIN: Record<string, () => Promise<WorkspaceAdapter>> = {
+  worktree: lazy(async () => (await import("./worktree")).WorktreeAdapter),
+}
+
+const state = new Map<ProjectID, Map<string, WorkspaceAdapter>>()
+
+export async function getAdapter(projectID: ProjectID, type: string): Promise<WorkspaceAdapter> {
+  const custom = state.get(projectID)?.get(type)
+  if (custom) return custom
+
+  const builtin = BUILTIN[type]
+  if (builtin) return builtin()
+
+  throw new Error(`Unknown workspace adapter: ${type}`)
+}
+
+export async function listAdapters(projectID: ProjectID): Promise<WorkspaceAdapterEntry[]> {
+  const builtin = await Promise.all(
+    Object.entries(BUILTIN).map(async ([type, init]) => {
+      const adapter = await init()
+      return {
+        type,
+        name: adapter.name,
+        description: adapter.description,
+      }
+    }),
+  )
+  const custom = [...(state.get(projectID)?.entries() ?? [])].map(([type, adapter]) => ({
+    type,
+    name: adapter.name,
+    description: adapter.description,
+  }))
+  return [...builtin, ...custom]
+}
+
+// Plugins can be loaded per-project so we need to scope them. If you
+// want to install a global one pass `ProjectID.global`
+export function registerAdapter(projectID: ProjectID, type: string, adapter: WorkspaceAdapter) {
+  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
+  adapters.set(type, adapter)
+  state.set(projectID, adapters)
+}
@@ -1,5 +1,7 @@
 import { Schema } from "effect"
-import { type WorkspaceAdaptor, WorkspaceInfo } from "../types"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Worktree } from "@/worktree"
+import { type WorkspaceAdapter, WorkspaceInfo } from "../types"

 const WorktreeConfig = Schema.Struct({
  name: WorkspaceInfo.fields.name,
@@ -8,26 +10,19 @@ const WorktreeConfig = Schema.Struct({
 })
 const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)

-async function loadWorktree() {
-  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
-  return { AppRuntime, Worktree }
-}
-
-export const WorktreeAdaptor: WorkspaceAdaptor = {
+export const WorktreeAdapter: WorkspaceAdapter = {
  name: "Worktree",
  description: "Create a git worktree",
  async configure(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const next = await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.makeWorktreeInfo()))
+    const worktree = await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.makeWorktreeInfo()))
    return {
      ...info,
-      name: next.name,
-      branch: next.branch,
-      directory: next.directory,
+      name: worktree.name,
+      branch: worktree.branch,
+      directory: worktree.directory,
    }
  },
  async create(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
    const config = decodeWorktreeConfig(info)
    await AppRuntime.runPromise(
      Worktree.Service.use((svc) =>
@@ -40,7 +35,6 @@ export const WorktreeAdaptor: WorkspaceAdaptor = {
    )
  },
  async remove(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
    const config = decodeWorktreeConfig(info)
    await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.remove({ directory: config.directory })))
  },
@@ -1,45 +0,0 @@
-import type { ProjectID } from "@/project/schema"
-import type { WorkspaceAdaptor, WorkspaceAdaptorEntry } from "../types"
-import { WorktreeAdaptor } from "./worktree"
-
-const BUILTIN: Record<string, WorkspaceAdaptor> = {
-  worktree: WorktreeAdaptor,
-}
-
-const state = new Map<ProjectID, Map<string, WorkspaceAdaptor>>()
-
-export function getAdaptor(projectID: ProjectID, type: string): WorkspaceAdaptor {
-  const custom = state.get(projectID)?.get(type)
-  if (custom) return custom
-
-  const builtin = BUILTIN[type]
-  if (builtin) return builtin
-
-  throw new Error(`Unknown workspace adaptor: ${type}`)
-}
-
-export async function listAdaptors(projectID: ProjectID): Promise<WorkspaceAdaptorEntry[]> {
-  const builtin = await Promise.all(
-    Object.entries(BUILTIN).map(async ([type, adaptor]) => {
-      return {
-        type,
-        name: adaptor.name,
-        description: adaptor.description,
-      }
-    }),
-  )
-  const custom = [...(state.get(projectID)?.entries() ?? [])].map(([type, adaptor]) => ({
-    type,
-    name: adaptor.name,
-    description: adaptor.description,
-  }))
-  return [...builtin, ...custom]
-}
-
-// Plugins can be loaded per-project so we need to scope them. If you
-// want to install a global one pass `ProjectID.global`
-export function registerAdaptor(projectID: ProjectID, type: string, adaptor: WorkspaceAdaptor) {
-  const adaptors = state.get(projectID) ?? new Map<string, WorkspaceAdaptor>()
-  adaptors.set(type, adaptor)
-  state.set(projectID, adaptors)
-}
@@ -1,19 +0,0 @@
-This is a plugin to simulate a remote environment locally. Add this to `.opencode/opencode.jsonc`:
-
-```json
-  "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"],
-```
-
-In a separate terminal, run a separate OpenCode server. This will act like a remote server and the local instance will proxy all requests to it:
-
-```
-./packages/opencode/script/run-workspace-server
-```
-
-With the plugin install, you can now run OpenCode and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
-
-How this works:
-
- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.
@@ -0,0 +1,66 @@
+export async function parseSSE(
+  body: ReadableStream<Uint8Array>,
+  signal: AbortSignal,
+  onEvent: (event: unknown) => void,
+) {
+  const reader = body.getReader()
+  const decoder = new TextDecoder()
+  let buf = ""
+  let last = ""
+  let retry = 1000
+
+  const abort = () => {
+    void reader.cancel().catch(() => undefined)
+  }
+
+  signal.addEventListener("abort", abort)
+
+  try {
+    while (!signal.aborted) {
+      const chunk = await reader.read().catch(() => ({ done: true, value: undefined as Uint8Array | undefined }))
+      if (chunk.done) break
+
+      buf += decoder.decode(chunk.value, { stream: true })
+      buf = buf.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+
+      const chunks = buf.split("\n\n")
+      buf = chunks.pop() ?? ""
+
+      chunks.forEach((chunk) => {
+        const data: string[] = []
+        chunk.split("\n").forEach((line) => {
+          if (line.startsWith("data:")) {
+            data.push(line.replace(/^data:\s*/, ""))
+            return
+          }
+          if (line.startsWith("id:")) {
+            last = line.replace(/^id:\s*/, "")
+            return
+          }
+          if (line.startsWith("retry:")) {
+            const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10)
+            if (!Number.isNaN(parsed)) retry = parsed
+          }
+        })
+
+        if (!data.length) return
+        const raw = data.join("\n")
+        try {
+          onEvent(JSON.parse(raw))
+        } catch {
+          onEvent({
+            type: "sse.message",
+            properties: {
+              data: raw,
+              id: last || undefined,
+              retry,
+            },
+          })
+        }
+      })
+    }
+  } finally {
+    signal.removeEventListener("abort", abort)
+    reader.releaseLock()
+  }
+}
@@ -17,12 +17,12 @@ export const WorkspaceInfo = Schema.Struct({
  .pipe(withStatics((s) => ({ zod: zod(s) })))
 export type WorkspaceInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceInfo>>

-export const WorkspaceAdaptorEntry = Schema.Struct({
+export const WorkspaceAdapterEntry = Schema.Struct({
  type: Schema.String,
  name: Schema.String,
  description: Schema.String,
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type WorkspaceAdaptorEntry = Schema.Schema.Type<typeof WorkspaceAdaptorEntry>
+export type WorkspaceAdapterEntry = Schema.Schema.Type<typeof WorkspaceAdapterEntry>

 export type Target =
  | {
@@ -35,7 +35,7 @@ export type Target =
      headers?: HeadersInit
    }

-export type WorkspaceAdaptor = {
+export type WorkspaceAdapter = {
  name: string
  description: string
  configure(info: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>
@@ -1,23 +1,22 @@
 import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Effect } from "effect"

 export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (event: GlobalEvent) => boolean }) {
-  if (input.signal?.aborted) return Effect.fail(input.signal.reason ?? new Error("Request aborted"))
+  if (input.signal?.aborted) return Promise.reject(input.signal.reason ?? new Error("Request aborted"))

-  return Effect.callback<void, unknown>((resume) => {
+  return new Promise<void>((resolve, reject) => {
    const abort = () => {
      cleanup()
-      resume(Effect.fail(input.signal?.reason ?? new Error("Request aborted")))
+      reject(input.signal?.reason ?? new Error("Request aborted"))
    }

    const handler = (event: GlobalEvent) => {
      try {
        if (!input.fn(event)) return
        cleanup()
-        resume(Effect.void)
+        resolve()
      } catch (error) {
        cleanup()
-        resume(Effect.fail(error))
+        reject(error)
      }
    }

@@ -29,11 +28,10 @@ export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (e

    const timeout = setTimeout(() => {
      cleanup()
-      resume(Effect.fail(new Error("Timed out waiting for global event")))
+      reject(new Error("Timed out waiting for global event"))
    }, input.timeout)

    GlobalBus.on("event", handler)
    input.signal?.addEventListener("abort", abort, { once: true })
-    return Effect.sync(cleanup)
  })
 }
@@ -41,13 +41,11 @@ import { ToolRegistry } from "@/tool/registry"
 import { Format } from "@/format"
 import { Project } from "@/project/project"
 import { Vcs } from "@/project/vcs"
-import { Workspace } from "@/control-plane/workspace"
 import { Worktree } from "@/worktree"
 import { Pty } from "@/pty"
 import { Installation } from "@/installation"
 import { ShareNext } from "@/share/share-next"
 import { SessionShare } from "@/share/session"
-import { SyncEvent } from "@/sync"
 import { Npm } from "@opencode-ai/core/npm"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"

@@ -92,13 +90,11 @@ export const AppLayer = Layer.mergeAll(
  Format.defaultLayer,
  Project.defaultLayer,
  Vcs.defaultLayer,
-  Workspace.defaultLayer,
  Worktree.defaultLayer,
  Pty.defaultLayer,
  Installation.defaultLayer,
  ShareNext.defaultLayer,
  SessionShare.defaultLayer,
-  SyncEvent.defaultLayer,
 ).pipe(Layer.provideMerge(Observability.layer))

 const rt = ManagedRuntime.make(AppLayer, { memoMap })
@@ -1,4 +1,4 @@
-import { Effect, Exit, Fiber } from "effect"
+import { Effect, Fiber } from "effect"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
 import { Instance, type InstanceContext } from "@/project/instance"
 import type { WorkspaceID } from "@/control-plane/schema"
@@ -9,7 +9,6 @@ import { attachWith } from "./run-service"
 export interface Shape {
  readonly promise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
  readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>
-  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>
 }

 function restore<R>(instance: InstanceContext | undefined, workspace: WorkspaceID | undefined, fn: () => R): R {
@@ -44,14 +43,6 @@ export function make(): Effect.Effect<Shape> {
        restore(instance, workspace, () => Effect.runPromise(wrap(effect))),
      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
        restore(instance, workspace, () => Effect.runFork(wrap(effect))),
-      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        Effect.callback<A, E>((resume) => {
-          restore(instance, workspace, () =>
-            Effect.runPromiseExit(wrap(effect)).then((exit) =>
-              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
-            ),
-          )
-        }),
    } satisfies Shape
  })
 }
@@ -1,67 +0,0 @@
-import { Config, Context, Effect, Layer } from "effect"
-
-type ConfigMap = Record<string, Config.Config<unknown>>
-
-/**
- * The service shape inferred from an object of Effect `Config` definitions.
- */
-export type Shape<Fields extends ConfigMap> = {
-  readonly [Key in keyof Fields]: Config.Success<Fields[Key]>
-}
-
-/**
- * A Context service class with generated layers for config-backed services.
- */
-export type ServiceClass<Self, Id extends string, Service> = Context.ServiceClass<Self, Id, Service> & {
-  /** Provide already-parsed config, useful in tests. */
-  readonly layer: (input: Service) => Layer.Layer<Self>
-  /** Parse config once from the active Effect ConfigProvider and provide the service. */
-  readonly defaultLayer: Layer.Layer<Self, Config.ConfigError>
-}
-
-/**
- * Create a Context service whose implementation is derived from Effect `Config`.
- *
- * This keeps Effect `Config` as the source of truth for env names, defaults, and
- * validation while generating a typed service plus convenient production/test
- * layers.
- *
- * ```ts
- * class ServerAuthConfig extends ConfigService.Service<ServerAuthConfig>()(
- *   "@opencode/ServerAuthConfig",
- *   {
- *     password: Config.string("OPENCODE_SERVER_PASSWORD").pipe(Config.option),
- *     username: Config.string("OPENCODE_SERVER_USERNAME").pipe(Config.withDefault("opencode")),
- *   },
- * ) {}
- *
- * const live = ServerAuthConfig.defaultLayer
- * const test = ServerAuthConfig.layer({ password: Option.some("secret"), username: "kit" })
- * ```
- */
-export const Service =
-  <Self>() =>
-  <const Id extends string, const Fields extends ConfigMap>(id: Id, fields: Fields) => {
-    class ConfigTag extends Context.Service<Self, Shape<Fields>>()(id) {
-      static layer(input: Shape<Fields>) {
-        return Layer.succeed(this, this.of(input))
-      }
-
-      static get defaultLayer() {
-        return Layer.effect(
-          this,
-          Config.all(fields)
-            .asEffect()
-            .pipe(
-              // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Config.all preserves the field shape, but its conditional return type also supports iterable inputs.
-              Effect.map((config) => this.of(config as Shape<Fields>)),
-            ),
-        )
-      }
-    }
-
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The generated class carries typed static helpers.
-    return ConfigTag as ServiceClass<Self, Id, Shape<Fields>>
-  }
-
-export * as ConfigService from "./config-service"
@@ -1,38 +0,0 @@
-import { Context, Effect } from "effect"
-
-type EffectMethod = (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>
-
-type ServiceUse<Identifier, Shape> = {
-  readonly [Key in keyof Shape as Shape[Key] extends EffectMethod ? Key : never]: Shape[Key] extends (
-    ...args: infer Args
-  ) => infer Return
-    ? Args extends ReadonlyArray<unknown>
-      ? Return extends Effect.Effect<infer A, infer E, infer R>
-        ? (...args: Args) => Effect.Effect<A, E, R | Identifier>
-        : never
-      : never
-    : never
-}
-
-export const serviceUse = <Identifier, Shape>(tag: Context.Service<Identifier, Shape>) => {
-  // This is the only dynamic boundary: TypeScript knows the accessor shape,
-  // but Proxy property names are runtime values.
-  const access = new Proxy(
-    {},
-    {
-      get: (_, key) => {
-        if (typeof key !== "string") return undefined
-        return (...args: unknown[]) =>
-          tag.use((service) => {
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy keys are checked at runtime.
-            const method = service[key as keyof Shape]
-            if (typeof method !== "function") return Effect.die(new Error(`Service method not found: ${key}`))
-            // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- ServiceUse exposes only Effect-returning methods.
-            return (method as (...args: unknown[]) => Effect.Effect<unknown, unknown, unknown>)(...args)
-          })
-      },
-    },
-  )
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy implements the mapped accessor surface lazily.
-  return access as ServiceUse<Identifier, Shape>
-}
@@ -1,26 +0,0 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-
-export async function AzureAuthPlugin(_input: PluginInput): Promise<Hooks> {
-  const prompts = []
-  if (!process.env.AZURE_RESOURCE_NAME) {
-    prompts.push({
-      type: "text" as const,
-      key: "resourceName",
-      message: "Enter Azure Resource Name",
-      placeholder: "e.g. my-models",
-    })
-  }
-
-  return {
-    auth: {
-      provider: "azure",
-      methods: [
-        {
-          type: "api",
-          label: "API key",
-          prompts,
-        },
-      ],
-    },
-  }
-}
@@ -14,7 +14,6 @@ const ISSUER = "https://auth.openai.com"
 const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses"
 const OAUTH_PORT = 1455
 const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000
-const ALLOWED_MODELS = new Set(["gpt-5.5", "gpt-5.2", "gpt-5.3-codex", "gpt-5.4", "gpt-5.4-mini"])

 interface PkceCodes {
  verifier: string
@@ -359,45 +358,50 @@ function waitForOAuthCallback(pkce: PkceCodes, state: string): Promise<TokenResp

 export async function CodexAuthPlugin(input: PluginInput): Promise<Hooks> {
  return {
-    provider: {
-      id: "openai",
-      async models(provider, ctx) {
-        if (ctx.auth?.type !== "oauth") return provider.models
-
-        return Object.fromEntries(
-          Object.entries(provider.models)
-            .filter(([, model]) => {
-              if (ALLOWED_MODELS.has(model.api.id)) return true
-              const match = model.api.id.match(/^gpt-(\d+\.\d+)/)
-              return match ? parseFloat(match[1]) > 5.4 : false
-            })
-            .map(([modelID, model]) => [
-              modelID,
-              {
-                ...model,
-                cost: {
-                  input: 0,
-                  output: 0,
-                  cache: { read: 0, write: 0 },
-                },
-                limit: model.id.includes("gpt-5.5")
-                  ? {
-                      context: 400_000,
-                      input: 272_000,
-                      output: 128_000,
-                    }
-                  : model.limit,
-              },
-            ]),
-        )
-      },
-    },
    auth: {
      provider: "openai",
-      async loader(getAuth) {
+      async loader(getAuth, provider) {
        const auth = await getAuth()
        if (auth.type !== "oauth") return {}

+        // Filter models to only allowed Codex models for OAuth
+        const allowedModels = new Set([
+          "gpt-5.1-codex",
+          "gpt-5.1-codex-max",
+          "gpt-5.1-codex-mini",
+          "gpt-5.2",
+          "gpt-5.2-codex",
+          "gpt-5.3-codex",
+          "gpt-5.4",
+          "gpt-5.4-mini",
+        ])
+        for (const [modelId, model] of Object.entries(provider.models)) {
+          if (modelId.includes("codex")) continue
+          if (allowedModels.has(model.api.id)) continue
+          const match = model.api.id.match(/^gpt-(\d+\.\d+)/)
+          if (match && parseFloat(match[1]) > 5.4) continue
+          delete provider.models[modelId]
+        }
+
+        // Zero out costs for Codex (included with ChatGPT subscription)
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            output: 0,
+            cache: { read: 0, write: 0 },
+          }
+
+          // gpt-5.5 models temporarily have restricted context window size for codex plans
+          if (model.id.includes("gpt-5.5")) {
+            model.limit = {
+              context: 400_000,
+              //@ts-expect-error incorrect type for v1 sdk but works
+              input: 272_000,
+              output: 128_000,
+            }
+          }
+        }
+
        return {
          apiKey: OAUTH_DUMMY_KEY,
          async fetch(requestInput: RequestInfo | URL, init?: RequestInit) {
@@ -3,7 +3,7 @@ import type {
  PluginInput,
  Plugin as PluginInstance,
  PluginModule,
-  WorkspaceAdaptor as PluginWorkspaceAdaptor,
+  WorkspaceAdapter as PluginWorkspaceAdapter,
 } from "@opencode-ai/plugin"
 import { Config } from "@/config/config"
 import { Bus } from "../bus"
@@ -17,15 +17,14 @@ import { CopilotAuthPlugin } from "./github-copilot/copilot"
 import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
 import { PoeAuthPlugin } from "opencode-poe-auth"
 import { CloudflareAIGatewayAuthPlugin, CloudflareWorkersAuthPlugin } from "./cloudflare"
-import { AzureAuthPlugin } from "./azure"
 import { Effect, Layer, Context, Stream } from "effect"
 import { EffectBridge } from "@/effect/bridge"
 import { InstanceState } from "@/effect/instance-state"
 import { errorMessage } from "@/util/error"
 import { PluginLoader } from "./loader"
 import { parsePluginSpecifier, readPluginId, readV1Plugin, resolvePluginId } from "./shared"
-import { registerAdaptor } from "@/control-plane/adaptors"
-import type { WorkspaceAdaptor } from "@/control-plane/types"
+import { registerAdapter } from "@/control-plane/adapters"
+import type { WorkspaceAdapter } from "@/control-plane/types"

 const log = Log.create({ service: "plugin" })

@@ -62,7 +61,6 @@ const INTERNAL_PLUGINS: PluginInstance[] = [
  PoeAuthPlugin,
  CloudflareWorkersAuthPlugin,
  CloudflareAIGatewayAuthPlugin,
-  AzureAuthPlugin,
 ]

 function isServerPlugin(value: unknown): value is PluginInstance {
@@ -138,8 +136,8 @@ export const layer = Layer.effect(
          worktree: ctx.worktree,
          directory: ctx.directory,
          experimental_workspace: {
-            register(type: string, adaptor: PluginWorkspaceAdaptor) {
-              registerAdaptor(ctx.project.id, type, adaptor as WorkspaceAdaptor)
+            register(type: string, adapter: PluginWorkspaceAdapter) {
+              registerAdapter(ctx.project.id, type, adapter as WorkspaceAdapter)
            },
          },
          get serverUrl(): URL {
@@ -17,7 +17,6 @@ import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { zod } from "@/util/effect-zod"
 import { NonNegativeInt, withStatics } from "@/util/schema"
-import { serviceUse } from "@/effect/service-use"

 const log = Log.create({ service: "project" })

@@ -179,7 +178,7 @@ export const layer: Layer.Layer<
    const readCachedProjectId = Effect.fnUntraced(function* (dir: string) {
      return yield* fs.readFileString(pathSvc.join(dir, "opencode")).pipe(
        Effect.map((x) => x.trim()),
-        Effect.map((x) => ProjectID.make(x)),
+        Effect.map(ProjectID.make),
        Effect.catch(() => Effect.void),
      )
    })
@@ -486,8 +485,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(NodePath.layer),
 )

-export const use = serviceUse(Service)
-
 export function list() {
  return Database.use((db) =>
    db
@@ -199,26 +199,12 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
      }),
    azure: Effect.fnUntraced(function* (provider: Info) {
      const env = yield* dep.env()
-      const auth = yield* dep.auth(provider.id)
      const resource = iife(() => {
-        return [
-          provider.options?.resourceName,
-          auth?.type === "api" ? auth.metadata?.resourceName : undefined,
-          env["AZURE_RESOURCE_NAME"],
-        ].find((name) => typeof name === "string" && name.trim() !== "")
+        const name = provider.options?.resourceName
+        if (typeof name === "string" && name.trim() !== "") return name
+        return env["AZURE_RESOURCE_NAME"]
      })

-      if (!resource && !provider.options?.baseURL) {
-        return {
-          autoload: false,
-          async getModel() {
-            throw new Error(
-              "AZURE_RESOURCE_NAME is missing, set it using env var or reconnecting the azure provider and setting it",
-            )
-          },
-        }
-      }
-
      return {
        autoload: false,
        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
@@ -229,16 +215,11 @@ function custom(dep: CustomDep): Record<string, CustomLoader> {
            return sdk.responses(modelID)
          }
        },
-        options: {
-          resourceName: resource,
-        },
-        vars(_options): Record<string, string> {
-          if (resource) {
-            return {
-              AZURE_RESOURCE_NAME: resource,
-            }
+        options: {},
+        vars(_options) {
+          return {
+            ...(resource && { AZURE_RESOURCE_NAME: resource }),
          }
-          return {}
        },
      }
    }),
@@ -1140,33 +1121,6 @@ const layer: Layer.Layer<
          return true
        }

-        for (const hook of plugins) {
-          const p = hook.provider
-          const models = p?.models
-          if (!p || !models) continue
-
-          const providerID = ProviderID.make(p.id)
-          if (disabled.has(providerID)) continue
-
-          const provider = database[providerID]
-          if (!provider) continue
-          const pluginAuth = yield* auth.get(providerID).pipe(Effect.orDie)
-
-          provider.models = yield* Effect.promise(async () => {
-            const next = await models(provider, { auth: pluginAuth })
-            return Object.fromEntries(
-              Object.entries(next).map(([id, model]) => [
-                id,
-                {
-                  ...model,
-                  id: ModelID.make(id),
-                  providerID,
-                },
-              ]),
-            )
-          })
-        }
-
        // extend database from config
        for (const [providerID, provider] of configProviders) {
          const existing = database[providerID]
@@ -1353,6 +1307,33 @@ const layer: Layer.Layer<
          })
        }

+        for (const hook of plugins) {
+          const p = hook.provider
+          const models = p?.models
+          if (!p || !models) continue
+
+          const providerID = ProviderID.make(p.id)
+          if (disabled.has(providerID)) continue
+
+          const provider = providers[providerID]
+          if (!provider) continue
+          const pluginAuth = yield* auth.get(providerID).pipe(Effect.orDie)
+
+          provider.models = yield* Effect.promise(async () => {
+            const next = await models(provider, { auth: pluginAuth })
+            return Object.fromEntries(
+              Object.entries(next).map(([id, model]) => [
+                id,
+                {
+                  ...model,
+                  id: ModelID.make(id),
+                  providerID,
+                },
+              ]),
+            )
+          })
+        }
+
        for (const [id, provider] of Object.entries(providers)) {
          const providerID = ProviderID.make(id)
          if (!isProviderAllowed(providerID)) {
@@ -1058,16 +1058,7 @@ export function providerOptions(model: Provider.Model, options: { [x: string]: a
    return result
  }

-  // AI SDK packages that resolve providerOptionsName by splitting the
-  // provider name on "." (e.g. "wafer.ai" -> "wafer") need the same
-  // logic here so the key we write matches the key they read.
-  // Other SDKs (xai, mistral, groq, cohere, etc.) use hardcoded keys
-  // like "xai" or "cohere" - applying .split(".")[0] would break those.
-  const usesDotSplitOptions =
-    model.api.npm === "@ai-sdk/openai-compatible" ||
-    model.api.npm === "@ai-sdk/openai" ||
-    model.api.npm === "@ai-sdk/anthropic"
-  const key = sdkKey(model.api.npm) ?? (usesDotSplitOptions ? model.providerID.split(".")[0] : model.providerID)
+  const key = sdkKey(model.api.npm) ?? model.providerID
  // @ai-sdk/azure delegates to OpenAIChatLanguageModel which reads from
  // providerOptions["openai"], but OpenAIResponsesLanguageModel checks
  // "azure" first. Pass both so model options work on either code path.
@@ -5,6 +5,7 @@ import { InstanceState } from "@/effect/instance-state"
 import { EffectBridge } from "@/effect/bridge"
 import { lazy } from "@opencode-ai/core/util/lazy"
 import { Plugin } from "@/plugin"
+import { Instance } from "@/project/instance"
 import { Shell } from "@/shell/shell"
 import type { Proc } from "#pty"
 import * as Log from "@opencode-ai/core/util/log"
@@ -228,38 +229,42 @@ export const layer = Layer.effect(
        subscribers: new Map(),
      }
      s.sessions.set(id, session)
-      proc.onData((chunk) => {
-        session.cursor += chunk.length
+      proc.onData(
+        Instance.bind((chunk) => {
+          session.cursor += chunk.length

-        for (const [key, ws] of session.subscribers.entries()) {
-          if (ws.readyState !== 1) {
-            session.subscribers.delete(key)
-            continue
+          for (const [key, ws] of session.subscribers.entries()) {
+            if (ws.readyState !== 1) {
+              session.subscribers.delete(key)
+              continue
+            }
+            if (sock(ws) !== key) {
+              session.subscribers.delete(key)
+              continue
+            }
+            try {
+              ws.send(chunk)
+            } catch {
+              session.subscribers.delete(key)
+            }
          }
-          if (sock(ws) !== key) {
-            session.subscribers.delete(key)
-            continue
-          }
-          try {
-            ws.send(chunk)
-          } catch {
-            session.subscribers.delete(key)
-          }
-        }

-        session.buffer += chunk
-        if (session.buffer.length <= BUFFER_LIMIT) return
-        const excess = session.buffer.length - BUFFER_LIMIT
-        session.buffer = session.buffer.slice(excess)
-        session.bufferCursor += excess
-      })
-      proc.onExit(({ exitCode }) => {
-        if (session.info.status === "exited") return
-        log.info("session exited", { id, exitCode })
-        session.info.status = "exited"
-        bridge.fork(bus.publish(Event.Exited, { id, exitCode }))
-        bridge.fork(remove(id))
-      })
+          session.buffer += chunk
+          if (session.buffer.length <= BUFFER_LIMIT) return
+          const excess = session.buffer.length - BUFFER_LIMIT
+          session.buffer = session.buffer.slice(excess)
+          session.bufferCursor += excess
+        }),
+      )
+      proc.onExit(
+        Instance.bind(({ exitCode }) => {
+          if (session.info.status === "exited") return
+          log.info("session exited", { id, exitCode })
+          session.info.status = "exited"
+          bridge.fork(bus.publish(Event.Exited, { id, exitCode }))
+          bridge.fork(remove(id))
+        }),
+      )
      yield* bus.publish(Event.Created, { info })
      return info
    })
@@ -1,24 +0,0 @@
-import { Effect } from "effect"
-
-const inputDecoder = new TextDecoder("utf-8", { fatal: true })
-
-export function handlePtyInput(
-  handler: { onMessage: (message: string | ArrayBuffer) => void },
-  message: string | Uint8Array,
-) {
-  if (typeof message === "string") {
-    handler.onMessage(message)
-    return Effect.void
-  }
-  return Effect.try({
-    try: () => inputDecoder.decode(message),
-    catch: () => new Error("invalid PTY websocket input"),
-  }).pipe(
-    Effect.catch(() => Effect.succeed(undefined)),
-    Effect.flatMap((decoded) => {
-      if (decoded === undefined) return Effect.void
-      handler.onMessage(decoded)
-      return Effect.void
-    }),
-  )
-}
@@ -1,12 +0,0 @@
-const opencodeOrigin = /^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/
-
-export function isAllowedCorsOrigin(input: string | undefined, opts?: { cors?: string[] }) {
-  if (!input) return true
-  if (input.startsWith("http://localhost:")) return true
-  if (input.startsWith("http://127.0.0.1:")) return true
-  if (input.startsWith("oc://renderer")) return true
-  if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
-    return true
-  if (opencodeOrigin.test(input)) return true
-  return opts?.cors?.includes(input) ?? false
-}
@@ -5,8 +5,6 @@ import { EventSequenceTable } from "@/sync/event.sql"
 import { Workspace } from "@/control-plane/workspace"
 import type { WorkspaceID } from "@/control-plane/schema"
 import * as Log from "@opencode-ai/core/util/log"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Effect } from "effect"

 const HEADER = "x-opencode-sync"
 type State = Record<string, number>
@@ -56,22 +54,16 @@ export function parse(headers: Headers) {
  ) as State
 }

-export function waitEffect(workspaceID: WorkspaceID, state: State, signal?: AbortSignal) {
-  return Effect.gen(function* () {
-    log.info("waiting for state", {
-      workspaceID,
-      state,
-    })
-    yield* Workspace.Service.use((workspace) => workspace.waitForSync(workspaceID, state, signal))
-    log.info("state fully synced", {
-      workspaceID,
-      state,
-    })
-  })
-}
-
 export async function wait(workspaceID: WorkspaceID, state: State, signal?: AbortSignal) {
-  await AppRuntime.runPromise(waitEffect(workspaceID, state, signal))
+  log.info("waiting for state", {
+    workspaceID,
+    state,
+  })
+  await Workspace.waitForSync(workspaceID, state, signal)
+  log.info("state fully synced", {
+    workspaceID,
+    state,
+  })
 }

 export const FenceMiddleware: MiddlewareHandler = async (c, next) => {
@@ -11,7 +11,6 @@ import { basicAuth } from "hono/basic-auth"
 import { cors } from "hono/cors"
 import { compress } from "hono/compress"
 import * as ServerBackend from "./backend"
-import { isAllowedCorsOrigin } from "./cors"

 const log = Log.create({ service: "server" })

@@ -71,7 +70,15 @@ export function CorsMiddleware(opts?: { cors?: string[] }): MiddlewareHandler {
  return cors({
    maxAge: 86_400,
    origin(input) {
-      if (isAllowedCorsOrigin(input, opts)) return input
+      if (!input) return
+
+      if (input.startsWith("http://localhost:")) return input
+      if (input.startsWith("http://127.0.0.1:")) return input
+      if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
+        return input
+
+      if (/^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(input)) return input
+      if (opts?.cors?.includes(input)) return input
    },
  })
 }
@@ -4,7 +4,6 @@ import * as Log from "@opencode-ai/core/util/log"
 import * as Fence from "./fence"
 import type { WorkspaceID } from "@/control-plane/schema"
 import { Workspace } from "@/control-plane/workspace"
-import { AppRuntime } from "@/effect/app-runtime"
 import { ProxyUtil } from "./proxy-util"
 import { Effect, Stream } from "effect"
 import { FetchHttpClient, HttpBody, HttpClient, HttpClientRequest } from "effect/unstable/http"
@@ -70,17 +69,18 @@ function statusText(response: unknown) {
 }

 export function httpEffect(url: string | URL, extra: HeadersInit | undefined, req: Request, workspaceID: WorkspaceID) {
-  return Effect.gen(function* () {
-    const syncing = yield* Workspace.Service.use((workspace) => workspace.isSyncing(workspaceID))
-    if (!syncing) {
-      return new Response(`broken sync connection for workspace: ${workspaceID}`, {
+  if (!Workspace.isSyncing(workspaceID)) {
+    return Effect.succeed(
+      new Response(`broken sync connection for workspace: ${workspaceID}`, {
        status: 503,
        headers: {
          "content-type": "text/plain; charset=utf-8",
        },
-      })
-    }
+      }),
+    )
+  }

+  return Effect.gen(function* () {
    const response = yield* HttpClient.execute(
      HttpClientRequest.make(req.method as never)(url, {
        headers: ProxyUtil.headers(req, extra),
@@ -100,7 +100,7 @@ export function httpEffect(url: string | URL, extra: HeadersInit | undefined, re
    next.delete("content-encoding")
    next.delete("content-length")

-    if (sync) yield* Fence.waitEffect(workspaceID, sync, req.signal)
+    if (sync) yield* Effect.promise(() => Fence.wait(workspaceID, sync, req.signal))
    const body = yield* Stream.toReadableStreamEffect(response.stream.pipe(Stream.catchCause(() => Stream.empty)))
    return new Response(body, {
      status: response.status,
@@ -114,7 +114,7 @@ export function httpEffect(url: string | URL, extra: HeadersInit | undefined, re
 }

 export function http(url: string | URL, extra: HeadersInit | undefined, req: Request, workspaceID: WorkspaceID) {
-  return AppRuntime.runPromise(httpEffect(url, extra, req, workspaceID))
+  return Effect.runPromise(httpEffect(url, extra, req, workspaceID))
 }

 export function websocket(
@@ -1,11 +1,9 @@
 import { Hono } from "hono"
 import { describeRoute, resolver, validator } from "hono-openapi"
 import z from "zod"
-import { Effect } from "effect"
-import { listAdaptors } from "@/control-plane/adaptors"
+import { listAdapters } from "@/control-plane/adapters"
 import { Workspace } from "@/control-plane/workspace"
-import { AppRuntime } from "@/effect/app-runtime"
-import { WorkspaceAdaptorEntry } from "@/control-plane/types"
+import { WorkspaceAdapterEntry } from "@/control-plane/types"
 import { zodObject } from "@/util/effect-zod"
 import { Instance } from "@/project/instance"
 import { errors } from "../../error"
@@ -18,24 +16,24 @@ const log = Log.create({ service: "server.workspace" })
 export const WorkspaceRoutes = lazy(() =>
  new Hono()
    .get(
-      "/adaptor",
+      "/adapter",
      describeRoute({
-        summary: "List workspace adaptors",
-        description: "List all available workspace adaptors for the current project.",
-        operationId: "experimental.workspace.adaptor.list",
+        summary: "List workspace adapters",
+        description: "List all available workspace adapters for the current project.",
+        operationId: "experimental.workspace.adapter.list",
        responses: {
          200: {
-            description: "Workspace adaptors",
+            description: "Workspace adapters",
            content: {
              "application/json": {
-                schema: resolver(z.array(zodObject(WorkspaceAdaptorEntry))),
+                schema: resolver(z.array(zodObject(WorkspaceAdapterEntry))),
              },
            },
          },
        },
      }),
      async (c) => {
-        return c.json(await listAdaptors(Instance.project.id))
+        return c.json(await listAdapters(Instance.project.id))
      },
    )
    .post(
@@ -64,14 +62,10 @@ export const WorkspaceRoutes = lazy(() =>
      ),
      async (c) => {
        const body = c.req.valid("json") as Omit<Workspace.CreateInput, "projectID">
-        const workspace = await AppRuntime.runPromise(
-          Workspace.Service.use((svc) =>
-            svc.create({
-              projectID: Instance.project.id,
-              ...body,
-            }),
-          ),
-        )
+        const workspace = await Workspace.create({
+          projectID: Instance.project.id,
+          ...body,
+        })
        return c.json(workspace)
      },
    )
@@ -93,7 +87,7 @@ export const WorkspaceRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        return c.json(await AppRuntime.runPromise(Workspace.Service.use((svc) => svc.list(Instance.project))))
+        return c.json(Workspace.list(Instance.project))
      },
    )
    .get(
@@ -114,11 +108,8 @@ export const WorkspaceRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        const result = await AppRuntime.runPromise(
-          Workspace.Service.use((svc) => Effect.all([svc.list(Instance.project), svc.status()])),
-        )
-        const ids = new Set(result[0].map((item) => item.id))
-        return c.json(result[1].filter((item) => ids.has(item.workspaceID)))
+        const ids = new Set(Workspace.list(Instance.project).map((item) => item.id))
+        return c.json(Workspace.status().filter((item) => ids.has(item.workspaceID)))
      },
    )
    .delete(
@@ -147,7 +138,7 @@ export const WorkspaceRoutes = lazy(() =>
      ),
      async (c) => {
        const { id } = c.req.valid("param")
-        return c.json(await AppRuntime.runPromise(Workspace.Service.use((svc) => svc.remove(id))))
+        return c.json(await Workspace.remove(id))
      },
    )
    .post(
@@ -183,14 +174,10 @@ export const WorkspaceRoutes = lazy(() =>
          directory: Instance.directory,
        })
        try {
-          const result = await AppRuntime.runPromise(
-            Workspace.Service.use((svc) =>
-              svc.sessionRestore({
-                workspaceID: id,
-                ...body,
-              }),
-            ),
-          )
+          const result = await Workspace.sessionRestore({
+            workspaceID: id,
+            ...body,
+          })
          log.info("session restore route complete", {
            workspaceID: id,
            sessionID: body.sessionID,
@@ -1,35 +0,0 @@
-# HttpApi Route Patterns
-
-Use `HttpApiBuilder.group(...)` for normal HTTP endpoints, including streaming HTTP responses such as server-sent events. Handlers should yield stable services once while building the handler layer, then close over those services in endpoint implementations.
-
-```ts
-export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session", (handlers) =>
-  Effect.gen(function* () {
-    const session = yield* Session.Service
-
-    return handlers.handle("list", () => session.list())
-  }),
-)
-```
-
-For SSE endpoints, stay in `HttpApiBuilder.group(...)` and return `HttpServerResponse.stream(...)` from the handler. Annotate the endpoint success schema with `HttpApiSchema.asText({ contentType: "text/event-stream" })` so OpenAPI documents the stream content type.
-
-Use raw `HttpRouter.use(...)` only for routes that do not fit the request/response HttpApi model, such as WebSocket upgrade routes or catch-all fallback routes. Yield stable services at route-layer construction and close over them in `router.add(...)` callbacks.
-
-```ts
-export const rawRoute = HttpRouter.use((router) =>
-  Effect.gen(function* () {
-    const pty = yield* Pty.Service
-
-    yield* router.add("GET", PtyPaths.connect, (request) => connectPty(request, pty))
-  }),
-)
-```
-
-Avoid `Effect.provide(SomeLayer)` inside request handlers or raw route callbacks. Stable layers should be provided once at the application/layer boundary, not rebuilt or scoped per request.
-
-Avoid `HttpRouter.provideRequest(...)` unless the dependency is intentionally request-level. Prefer `HttpRouter.use(...)` for stable app services.
-
-Use `Effect.provideService(...)` in middleware only for request-derived context, such as `WorkspaceRouteContext`, `InstanceRef`, or `WorkspaceRef`. Do not use it to smuggle stable services through request effects when they can be yielded at layer construction.
-
-When adding middleware, compose it at the layer boundary and keep the route tree explicit in `server.ts`. Shared router middleware such as auth, workspace routing, and instance context should stay visible where routes are assembled.
@@ -2,8 +2,8 @@ import { Bus } from "@/bus"
 import * as Log from "@opencode-ai/core/util/log"
 import { Effect, Schema } from "effect"
 import * as Stream from "effect/Stream"
-import { HttpServerResponse } from "effect/unstable/http"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http"
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import * as Sse from "effect/unstable/encoding/Sse"

 const log = Log.create({ service: "server" })
@@ -16,7 +16,7 @@ export const EventApi = HttpApi.make("event").add(
  HttpApiGroup.make("event")
    .add(
      HttpApiEndpoint.get("subscribe", EventPaths.event, {
-        success: Schema.String.pipe(HttpApiSchema.asText({ contentType: "text/event-stream" })),
+        success: Schema.Unknown,
      }).annotateMerge(
        OpenApi.annotations({
          identifier: "event.subscribe",
@@ -37,41 +37,34 @@ function eventData(data: unknown): Sse.Event {
  }
 }

-function eventResponse(bus: Bus.Interface) {
-  const events = bus.subscribeAll().pipe(Stream.takeUntil((event) => event.type === Bus.InstanceDisposed.type))
-  const heartbeat = Stream.tick("10 seconds").pipe(
-    Stream.drop(1),
-    Stream.map(() => ({ type: "server.heartbeat", properties: {} })),
-  )
-
-  log.info("event connected")
-  return HttpServerResponse.stream(
-    Stream.make({ type: "server.connected", properties: {} }).pipe(
-      Stream.concat(events.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }))),
-      Stream.map(eventData),
-      Stream.pipeThroughChannel(Sse.encode()),
-      Stream.encodeText,
-      Stream.ensuring(Effect.sync(() => log.info("event disconnected"))),
-    ),
-    {
-      contentType: "text/event-stream",
-      headers: {
-        "Cache-Control": "no-cache, no-transform",
-        "X-Accel-Buffering": "no",
-        "X-Content-Type-Options": "nosniff",
-      },
-    },
-  )
-}
-
-export const eventHandlers = HttpApiBuilder.group(EventApi, "event", (handlers) =>
+export const eventRoute = HttpRouter.add(
+  "GET",
+  EventPaths.event,
  Effect.gen(function* () {
    const bus = yield* Bus.Service
-    return handlers.handleRaw(
-      "subscribe",
-      Effect.fn("EventHttpApi.subscribe")(function* () {
-        return eventResponse(bus)
-      }),
+    const events = bus.subscribeAll().pipe(Stream.takeUntil((event) => event.type === Bus.InstanceDisposed.type))
+    const heartbeat = Stream.tick("10 seconds").pipe(
+      Stream.drop(1),
+      Stream.map(() => ({ type: "server.heartbeat", properties: {} })),
    )
-  }),
+
+    log.info("event connected")
+    return HttpServerResponse.stream(
+      Stream.make({ type: "server.connected", properties: {} }).pipe(
+        Stream.concat(events.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }))),
+        Stream.map(eventData),
+        Stream.pipeThroughChannel(Sse.encode()),
+        Stream.encodeText,
+        Stream.ensuring(Effect.sync(() => log.info("event disconnected"))),
+      ),
+      {
+        contentType: "text/event-stream",
+        headers: {
+          "Cache-Control": "no-cache, no-transform",
+          "X-Accel-Buffering": "no",
+          "X-Content-Type-Options": "nosniff",
+        },
+      },
+    )
+  }).pipe(Effect.provide(Bus.layer)),
 )
@@ -15,7 +15,6 @@ export const AddPayload = Schema.Struct({
 export const StatusMap = Schema.Record(Schema.String, MCP.Status)
 export const AuthStartResponse = Schema.Struct({
  authorizationUrl: Schema.String,
-  oauthState: Schema.String,
 })
 export const AuthCallbackPayload = Schema.Struct({
  code: Schema.String,
@@ -10,6 +10,7 @@ import { SessionSummary } from "@/session/summary"
 import { Todo } from "@/session/todo"
 import { MessageID, PartID, SessionID } from "@/session/schema"
 import { Snapshot } from "@/snapshot"
+import { NonNegativeInt } from "@/util/schema"
 import { Schema, SchemaGetter, Struct } from "effect"
 import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "../middleware/authorization"
@@ -44,7 +45,7 @@ export const UpdatePayload = Schema.Struct({
  permission: Schema.optional(Permission.Ruleset),
  time: Schema.optional(
    Schema.Struct({
-      archived: Schema.optional(Session.ArchivedTimestamp),
+      archived: Schema.optional(NonNegativeInt),
    }),
  ),
 })
@@ -1,5 +1,5 @@
 import { Workspace } from "@/control-plane/workspace"
-import { WorkspaceAdaptorEntry } from "@/control-plane/types"
+import { WorkspaceAdapterEntry } from "@/control-plane/types"
 import { NonNegativeInt } from "@/util/schema"
 import { Schema, Struct } from "effect"
 import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
@@ -16,7 +16,7 @@ export const SessionRestoreResponse = Schema.Struct({
 })

 export const WorkspacePaths = {
-  adaptors: `${root}/adaptor`,
+  adapters: `${root}/adapter`,
  list: root,
  status: `${root}/status`,
  remove: `${root}/:id`,
@@ -27,13 +27,13 @@ export const WorkspaceApi = HttpApi.make("workspace")
  .add(
    HttpApiGroup.make("workspace")
      .add(
-        HttpApiEndpoint.get("adaptors", WorkspacePaths.adaptors, {
-          success: described(Schema.Array(WorkspaceAdaptorEntry), "Workspace adaptors"),
+        HttpApiEndpoint.get("adapters", WorkspacePaths.adapters, {
+          success: described(Schema.Array(WorkspaceAdapterEntry), "Workspace adapters"),
        }).annotateMerge(
          OpenApi.annotations({
-            identifier: "experimental.workspace.adaptor.list",
-            summary: "List workspace adaptors",
-            description: "List all available workspace adaptors for the current project.",
+            identifier: "experimental.workspace.adapter.list",
+            summary: "List workspace adapters",
+            description: "List all available workspace adapters for the current project.",
          }),
        ),
        HttpApiEndpoint.get("list", WorkspacePaths.list, {
@@ -1,6 +1,6 @@
+import { EffectBridge } from "@/effect/bridge"
 import { Pty } from "@/pty"
 import { PtyID } from "@/pty/schema"
-import { handlePtyInput } from "@/pty/input"
 import { Shell } from "@/shell/shell"
 import { Effect } from "effect"
 import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
@@ -22,11 +22,16 @@ export const ptyHandlers = HttpApiBuilder.group(InstanceHttpApi, "pty", (handler
    })

    const create = Effect.fn("PtyHttpApi.create")(function* (ctx: { payload: typeof Pty.CreateInput.Type }) {
-      return yield* pty.create({
-        ...ctx.payload,
-        args: ctx.payload.args ? [...ctx.payload.args] : undefined,
-        env: ctx.payload.env ? { ...ctx.payload.env } : undefined,
-      })
+      const bridge = yield* EffectBridge.make()
+      return yield* Effect.promise(() =>
+        bridge.promise(
+          pty.create({
+            ...ctx.payload,
+            args: ctx.payload.args ? [...ctx.payload.args] : undefined,
+            env: ctx.payload.env ? { ...ctx.payload.env } : undefined,
+          }),
+        ),
+      )
    })

    const get = Effect.fn("PtyHttpApi.get")(function* (ctx: { params: { ptyID: PtyID } }) {
@@ -62,60 +67,54 @@ export const ptyHandlers = HttpApiBuilder.group(InstanceHttpApi, "pty", (handler
  }),
 )

-export const ptyConnectRoute = HttpRouter.use((router) =>
+export const ptyConnectRoute = HttpRouter.add(
+  "GET",
+  PtyPaths.connect,
  Effect.gen(function* () {
    const pty = yield* Pty.Service
-    yield* router.add(
-      "GET",
-      PtyPaths.connect,
-      Effect.gen(function* () {
-        const params = yield* HttpRouter.schemaPathParams(Params)
-        if (!(yield* pty.get(params.ptyID))) return HttpServerResponse.empty({ status: 404 })
+    const params = yield* HttpRouter.schemaPathParams(Params)
+    if (!(yield* pty.get(params.ptyID))) return HttpServerResponse.empty({ status: 404 })

-        const query = yield* HttpServerRequest.schemaSearchParams(CursorQuery)
-        const parsedCursor = query.cursor === undefined ? undefined : Number(query.cursor)
-        const cursor =
-          parsedCursor !== undefined && Number.isSafeInteger(parsedCursor) && parsedCursor >= -1
-            ? parsedCursor
-            : undefined
-        const socket = yield* Effect.orDie((yield* HttpServerRequest.HttpServerRequest).upgrade)
-        const write = yield* socket.writer
-        const services = yield* Effect.context()
-        const writeScoped = (effect: Effect.Effect<void, unknown>) => {
-          Effect.runForkWith(services)(effect.pipe(Effect.catch(() => Effect.void)))
-        }
-        let closed = false
-        const adapter = {
-          get readyState() {
-            return closed ? 3 : 1
-          },
-          send: (data: string | Uint8Array | ArrayBuffer) => {
-            if (closed) return
-            writeScoped(write(data instanceof ArrayBuffer ? new Uint8Array(data) : data))
-          },
-          close: (code?: number, reason?: string) => {
-            if (closed) return
+    const query = yield* HttpServerRequest.schemaSearchParams(CursorQuery)
+    const parsedCursor = query.cursor === undefined ? undefined : Number(query.cursor)
+    const cursor =
+      parsedCursor !== undefined && Number.isSafeInteger(parsedCursor) && parsedCursor >= -1 ? parsedCursor : undefined
+    const socket = yield* Effect.orDie((yield* HttpServerRequest.HttpServerRequest).upgrade)
+    const write = yield* socket.writer
+    let closed = false
+    const adapter = {
+      get readyState() {
+        return closed ? 3 : 1
+      },
+      send: (data: string | Uint8Array | ArrayBuffer) => {
+        if (closed) return
+        Effect.runFork(
+          write(data instanceof ArrayBuffer ? new Uint8Array(data) : data).pipe(Effect.catch(() => Effect.void)),
+        )
+      },
+      close: (code?: number, reason?: string) => {
+        if (closed) return
+        closed = true
+        Effect.runFork(write(new Socket.CloseEvent(code, reason)).pipe(Effect.catch(() => Effect.void)))
+      },
+    }
+    const handler = yield* pty.connect(params.ptyID, adapter, cursor)
+    if (!handler) return HttpServerResponse.empty()
+
+    yield* socket
+      .runRaw((message) => {
+        handler.onMessage(typeof message === "string" ? message : message.slice().buffer)
+      })
+      .pipe(
+        Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
+        Effect.ensuring(
+          Effect.sync(() => {
            closed = true
-            writeScoped(write(new Socket.CloseEvent(code, reason)))
-          },
-        }
-        const handler = yield* pty.connect(params.ptyID, adapter, cursor)
-        if (!handler) return HttpServerResponse.empty()
-
-        yield* socket
-          .runRaw((message) => handlePtyInput(handler, message))
-          .pipe(
-            Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
-            Effect.ensuring(
-              Effect.sync(() => {
-                closed = true
-                handler.onClose()
-              }),
-            ),
-            Effect.orDie,
-          )
-        return HttpServerResponse.empty()
-      }),
-    )
-  }),
+            handler.onClose()
+          }),
+        ),
+        Effect.orDie,
+      )
+    return HttpServerResponse.empty()
+  }).pipe(Effect.provide(Pty.defaultLayer)),
 )
@@ -1,5 +1,5 @@
 import * as InstanceState from "@/effect/instance-state"
-import { EffectBridge } from "@/effect/bridge"
+import { AppRuntime } from "@/effect/app-runtime"
 import { Agent } from "@/agent/agent"
 import { Bus } from "@/bus"
 import { Command } from "@/command"
@@ -18,8 +18,9 @@ import { SessionSummary } from "@/session/summary"
 import { Todo } from "@/session/todo"
 import { MessageID, PartID, SessionID } from "@/session/schema"
 import { NotFoundError } from "@/storage/storage"
+import * as Log from "@opencode-ai/core/util/log"
 import { NamedError } from "@opencode-ai/core/util/error"
-import { Cause, Effect, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import * as Stream from "effect/Stream"
 import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { HttpApiBuilder, HttpApiError, HttpApiSchema } from "effect/unstable/httpapi"
@@ -39,6 +40,8 @@ import {
  UpdatePayload,
 } from "../groups/session"

+const log = Log.create({ service: "server" })
+
 const mapNotFound = <A, E, R>(self: Effect.Effect<A, E, R>) =>
  self.pipe(
    Effect.catchIf(NotFoundError.isInstance, () => Effect.fail(new HttpApiError.NotFound({}))),
@@ -50,24 +53,16 @@ const mapNotFound = <A, E, R>(self: Effect.Effect<A, E, R>) =>
 export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session", (handlers) =>
  Effect.gen(function* () {
    const session = yield* Session.Service
-    const shareSvc = yield* SessionShare.Service
-    const promptSvc = yield* SessionPrompt.Service
-    const revertSvc = yield* SessionRevert.Service
-    const compactSvc = yield* SessionCompaction.Service
-    const runState = yield* SessionRunState.Service
-    const agentSvc = yield* Agent.Service
-    const permissionSvc = yield* Permission.Service
    const statusSvc = yield* SessionStatus.Service
    const todoSvc = yield* Todo.Service
    const summary = yield* SessionSummary.Service
-    const bus = yield* Bus.Service

    const list = Effect.fn("SessionHttpApi.list")(function* (ctx: { query: typeof ListQuery.Type }) {
      const instance = yield* InstanceState.context
      return Instance.restore(instance, () =>
        Array.from(
          Session.list({
-            directory: ctx.query.scope === "project" ? undefined : ctx.query.directory,
+            directory: ctx.query.directory,
            scope: ctx.query.scope,
            path: ctx.query.path,
            roots: ctx.query.roots,
@@ -153,7 +148,14 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
    })

    const create = Effect.fn("SessionHttpApi.create")(function* (ctx: { payload?: Session.CreateInput }) {
-      return yield* shareSvc.create(ctx.payload)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionShare.Service.use((svc) => svc.create(ctx.payload)).pipe(Effect.provide(SessionShare.defaultLayer)),
+          ),
+        ),
+      )
    })

    const createRaw = Effect.fn("SessionHttpApi.createRaw")(function* (ctx: {
@@ -173,7 +175,14 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
    })

    const remove = Effect.fn("SessionHttpApi.remove")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* session.remove(ctx.params.sessionID)
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Session.Service.use((svc) => svc.remove(ctx.params.sessionID)).pipe(Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
      return true
    })

@@ -181,31 +190,60 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      params: { sessionID: SessionID }
      payload: typeof UpdatePayload.Type
    }) {
-      const current = yield* session.get(ctx.params.sessionID)
-      if (ctx.payload.title !== undefined) {
-        yield* session.setTitle({ sessionID: ctx.params.sessionID, title: ctx.payload.title })
-      }
-      if (ctx.payload.permission !== undefined) {
-        yield* session.setPermission({
-          sessionID: ctx.params.sessionID,
-          permission: Permission.merge(current.permission ?? [], ctx.payload.permission),
-        })
-      }
-      if (ctx.payload.time?.archived !== undefined) {
-        yield* session.setArchived({ sessionID: ctx.params.sessionID, time: ctx.payload.time.archived })
-      }
-      return yield* session.get(ctx.params.sessionID)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Session.Service.use((svc) =>
+              Effect.gen(function* () {
+                const current = yield* svc.get(ctx.params.sessionID)
+                if (ctx.payload.title !== undefined) {
+                  yield* svc.setTitle({ sessionID: ctx.params.sessionID, title: ctx.payload.title })
+                }
+                if (ctx.payload.permission !== undefined) {
+                  yield* svc.setPermission({
+                    sessionID: ctx.params.sessionID,
+                    permission: Permission.merge(current.permission ?? [], ctx.payload.permission),
+                  })
+                }
+                if (ctx.payload.time?.archived !== undefined) {
+                  yield* svc.setArchived({ sessionID: ctx.params.sessionID, time: ctx.payload.time.archived })
+                }
+                return yield* svc.get(ctx.params.sessionID)
+              }),
+            ).pipe(Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
    })

    const fork = Effect.fn("SessionHttpApi.fork")(function* (ctx: {
      params: { sessionID: SessionID }
      payload: typeof ForkPayload.Type
    }) {
-      return yield* session.fork({ sessionID: ctx.params.sessionID, messageID: ctx.payload.messageID })
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Session.Service.use((svc) =>
+              svc.fork({ sessionID: ctx.params.sessionID, messageID: ctx.payload.messageID }),
+            ).pipe(Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
    })

    const abort = Effect.fn("SessionHttpApi.abort")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* promptSvc.cancel(ctx.params.sessionID)
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) => svc.cancel(ctx.params.sessionID)).pipe(
+              Effect.provide(SessionPrompt.defaultLayer),
+            ),
+          ),
+        ),
+      )
      return true
    })

@@ -213,45 +251,98 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      params: { sessionID: SessionID }
      payload: typeof InitPayload.Type
    }) {
-      yield* promptSvc.command({
-        sessionID: ctx.params.sessionID,
-        messageID: ctx.payload.messageID,
-        model: `${ctx.payload.providerID}/${ctx.payload.modelID}`,
-        command: Command.Default.INIT,
-        arguments: "",
-      })
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) =>
+              svc.command({
+                sessionID: ctx.params.sessionID,
+                messageID: ctx.payload.messageID,
+                model: `${ctx.payload.providerID}/${ctx.payload.modelID}`,
+                command: Command.Default.INIT,
+                arguments: "",
+              }),
+            ).pipe(Effect.provide(SessionPrompt.defaultLayer)),
+          ),
+        ),
+      )
      return true
    })

    const share = Effect.fn("SessionHttpApi.share")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* shareSvc.share(ctx.params.sessionID).pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
-      return yield* session.get(ctx.params.sessionID)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const share = yield* SessionShare.Service
+              const session = yield* Session.Service
+              yield* share.share(ctx.params.sessionID)
+              return yield* session.get(ctx.params.sessionID)
+            }).pipe(Effect.provide(SessionShare.defaultLayer)),
+          ),
+        ),
+      )
    })

    const unshare = Effect.fn("SessionHttpApi.unshare")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* shareSvc.unshare(ctx.params.sessionID).pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
-      return yield* session.get(ctx.params.sessionID)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const share = yield* SessionShare.Service
+              const session = yield* Session.Service
+              yield* share.unshare(ctx.params.sessionID)
+              return yield* session.get(ctx.params.sessionID)
+            }).pipe(Effect.provide(SessionShare.defaultLayer)),
+          ),
+        ),
+      )
    })

    const summarize = Effect.fn("SessionHttpApi.summarize")(function* (ctx: {
      params: { sessionID: SessionID }
      payload: typeof SummarizePayload.Type
    }) {
-      yield* revertSvc.cleanup(yield* session.get(ctx.params.sessionID))
-      const messages = yield* session.messages({ sessionID: ctx.params.sessionID })
-      const defaultAgent = yield* agentSvc.defaultAgent()
-      const currentAgent = messages.findLast((message) => message.info.role === "user")?.info.agent ?? defaultAgent
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const session = yield* Session.Service
+              const revert = yield* SessionRevert.Service
+              const compact = yield* SessionCompaction.Service
+              const prompt = yield* SessionPrompt.Service
+              const agent = yield* Agent.Service

-      yield* compactSvc.create({
-        sessionID: ctx.params.sessionID,
-        agent: currentAgent,
-        model: {
-          providerID: ctx.payload.providerID,
-          modelID: ctx.payload.modelID,
-        },
-        auto: ctx.payload.auto ?? false,
-      })
-      yield* promptSvc.loop({ sessionID: ctx.params.sessionID })
+              yield* revert.cleanup(yield* session.get(ctx.params.sessionID))
+              const messages = yield* session.messages({ sessionID: ctx.params.sessionID })
+              const defaultAgent = yield* agent.defaultAgent()
+              const currentAgent =
+                messages.findLast((message) => message.info.role === "user")?.info.agent ?? defaultAgent
+
+              yield* compact.create({
+                sessionID: ctx.params.sessionID,
+                agent: currentAgent,
+                model: {
+                  providerID: ctx.payload.providerID,
+                  modelID: ctx.payload.modelID,
+                },
+                auto: ctx.payload.auto ?? false,
+              })
+              yield* prompt.loop({ sessionID: ctx.params.sessionID })
+            }).pipe(
+              Effect.provide(SessionRevert.defaultLayer),
+              Effect.provide(SessionCompaction.defaultLayer),
+              Effect.provide(SessionPrompt.defaultLayer),
+              Effect.provide(Agent.defaultLayer),
+              Effect.provide(Session.defaultLayer),
+            ),
+          ),
+        ),
+      )
      return true
    })

@@ -259,14 +350,20 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      params: { sessionID: SessionID }
      payload: typeof PromptPayload.Type
    }) {
-      const bridge = yield* EffectBridge.make()
+      const instance = yield* InstanceState.context
      return HttpServerResponse.stream(
        Stream.fromEffect(
-          bridge.run(
-            promptSvc.prompt({
-              ...ctx.payload,
-              sessionID: ctx.params.sessionID,
-            }),
+          Effect.promise(() =>
+            Instance.restore(instance, () =>
+              AppRuntime.runPromise(
+                SessionPrompt.Service.use((svc) =>
+                  svc.prompt({
+                    ...ctx.payload,
+                    sessionID: ctx.params.sessionID,
+                  } as unknown as SessionPrompt.PromptInput),
+                ).pipe(Effect.provide(SessionPrompt.defaultLayer)),
+              ),
+            ),
          ),
        ).pipe(
          Stream.map((message) => JSON.stringify(message)),
@@ -280,21 +377,23 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      params: { sessionID: SessionID }
      payload: typeof PromptPayload.Type
    }) {
-      const bridge = yield* EffectBridge.make()
+      const instance = yield* InstanceState.context
      yield* Effect.sync(() => {
-        bridge.fork(
-          promptSvc.prompt({ ...ctx.payload, sessionID: ctx.params.sessionID }).pipe(
-            Effect.catchCause((cause) =>
-              Effect.gen(function* () {
-                yield* Effect.logError("prompt_async failed", { sessionID: ctx.params.sessionID, cause })
-                yield* bus.publish(Session.Event.Error, {
-                  sessionID: ctx.params.sessionID,
-                  error: new NamedError.Unknown({ message: Cause.pretty(cause) }).toObject(),
-                })
-              }),
-            ),
-          ),
-        )
+        Instance.restore(instance, () => {
+          void AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) =>
+              svc.prompt({ ...ctx.payload, sessionID: ctx.params.sessionID } as unknown as SessionPrompt.PromptInput),
+            ).pipe(Effect.provide(SessionPrompt.defaultLayer)),
+          ).catch((error) => {
+            log.error("prompt_async failed", { sessionID: ctx.params.sessionID, error })
+            void Bus.publish(Session.Event.Error, {
+              sessionID: ctx.params.sessionID,
+              error: new NamedError.Unknown({
+                message: error instanceof Error ? error.message : String(error),
+              }).toObject(),
+            })
+          })
+        })
      })
      return HttpApiSchema.NoContent.make()
    })
@@ -303,47 +402,111 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      params: { sessionID: SessionID }
      payload: typeof CommandPayload.Type
    }) {
-      return yield* promptSvc.command({ ...ctx.payload, sessionID: ctx.params.sessionID })
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) =>
+              svc.command({ ...ctx.payload, sessionID: ctx.params.sessionID } as SessionPrompt.CommandInput),
+            ).pipe(Effect.provide(SessionPrompt.defaultLayer)),
+          ),
+        ),
+      )
    })

    const shell = Effect.fn("SessionHttpApi.shell")(function* (ctx: {
      params: { sessionID: SessionID }
      payload: typeof ShellPayload.Type
    }) {
-      return yield* promptSvc.shell({ ...ctx.payload, sessionID: ctx.params.sessionID })
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) =>
+              svc.shell({ ...ctx.payload, sessionID: ctx.params.sessionID } as SessionPrompt.ShellInput),
+            ).pipe(Effect.provide(SessionPrompt.defaultLayer)),
+          ),
+        ),
+      )
    })

    const revert = Effect.fn("SessionHttpApi.revert")(function* (ctx: {
      params: { sessionID: SessionID }
      payload: typeof RevertPayload.Type
    }) {
-      return yield* revertSvc.revert({ sessionID: ctx.params.sessionID, ...ctx.payload })
+      const instance = yield* InstanceState.context
+      log.info("revert", ctx.payload)
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionRevert.Service.use((svc) => svc.revert({ sessionID: ctx.params.sessionID, ...ctx.payload })).pipe(
+              Effect.provide(SessionRevert.defaultLayer),
+            ),
+          ),
+        ),
+      )
    })

    const unrevert = Effect.fn("SessionHttpApi.unrevert")(function* (ctx: { params: { sessionID: SessionID } }) {
-      return yield* revertSvc.unrevert({ sessionID: ctx.params.sessionID })
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            SessionRevert.Service.use((svc) => svc.unrevert({ sessionID: ctx.params.sessionID })).pipe(
+              Effect.provide(SessionRevert.defaultLayer),
+            ),
+          ),
+        ),
+      )
    })

    const permissionRespond = Effect.fn("SessionHttpApi.permissionRespond")(function* (ctx: {
      params: { permissionID: PermissionID }
      payload: typeof PermissionResponsePayload.Type
    }) {
-      yield* permissionSvc.reply({ requestID: ctx.params.permissionID, reply: ctx.payload.response })
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Permission.Service.use((svc) =>
+              svc.reply({ requestID: ctx.params.permissionID, reply: ctx.payload.response }),
+            ).pipe(Effect.provide(Permission.defaultLayer)),
+          ),
+        ),
+      )
      return true
    })

    const deleteMessage = Effect.fn("SessionHttpApi.deleteMessage")(function* (ctx: {
      params: { sessionID: SessionID; messageID: MessageID }
    }) {
-      yield* runState.assertNotBusy(ctx.params.sessionID)
-      yield* session.removeMessage(ctx.params)
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const state = yield* SessionRunState.Service
+              const session = yield* Session.Service
+              yield* state.assertNotBusy(ctx.params.sessionID)
+              yield* session.removeMessage(ctx.params)
+            }).pipe(Effect.provide(SessionRunState.defaultLayer), Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
      return true
    })

    const deletePart = Effect.fn("SessionHttpApi.deletePart")(function* (ctx: {
      params: { sessionID: SessionID; messageID: MessageID; partID: PartID }
    }) {
-      yield* session.removePart(ctx.params)
+      const instance = yield* InstanceState.context
+      yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Session.Service.use((svc) => svc.removePart(ctx.params)).pipe(Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
      return true
    })

@@ -361,7 +524,14 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
          `Part mismatch: body.id='${payload.id}' vs partID='${ctx.params.partID}', body.messageID='${payload.messageID}' vs messageID='${ctx.params.messageID}', body.sessionID='${payload.sessionID}' vs sessionID='${ctx.params.sessionID}'`,
        )
      }
-      return yield* session.updatePart(payload)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          AppRuntime.runPromise(
+            Session.Service.use((svc) => svc.updatePart(payload)).pipe(Effect.provide(Session.defaultLayer)),
+          ),
+        ),
+      )
    })

    return handlers
@@ -1,4 +1,4 @@
-import { Workspace } from "@/control-plane/workspace"
+import { startWorkspaceSyncing } from "@/control-plane/workspace"
 import * as InstanceState from "@/effect/instance-state"
 import { Database } from "@/storage/db"
 import { SyncEvent } from "@/sync"
@@ -9,24 +9,15 @@ import { eq } from "drizzle-orm"
 import { lte } from "drizzle-orm"
 import { not } from "drizzle-orm"
 import { or } from "drizzle-orm"
-import { Effect, Scope } from "effect"
+import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../api"
 import { HistoryPayload, ReplayPayload } from "../groups/sync"
-import * as Log from "@opencode-ai/core/util/log"
-
-const log = Log.create({ service: "server.sync" })

 export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handlers) =>
  Effect.gen(function* () {
-    const workspace = yield* Workspace.Service
-    const scope = yield* Scope.Scope
-    const sync = yield* SyncEvent.Service
-
    const start = Effect.fn("SyncHttpApi.start")(function* () {
-      yield* workspace
-        .startWorkspaceSyncing((yield* InstanceState.context).project.id)
-        .pipe(Effect.ignore, Effect.forkIn(scope))
+      startWorkspaceSyncing((yield* InstanceState.context).project.id)
      return true
    })

@@ -38,22 +29,8 @@ export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handl
        type: event.type,
        data: { ...event.data },
      }))
-      const source = events[0].aggregateID
-      log.info("sync replay requested", {
-        sessionID: source,
-        events: events.length,
-        first: events[0]?.seq,
-        last: events.at(-1)?.seq,
-        directory: ctx.payload.directory,
-      })
-      yield* sync.replayAll(events)
-      log.info("sync replay complete", {
-        sessionID: source,
-        events: events.length,
-        first: events[0]?.seq,
-        last: events.at(-1)?.seq,
-      })
-      return { sessionID: source }
+      SyncEvent.replayAll(events)
+      return { sessionID: events[0].aggregateID }
    })

    const history = Effect.fn("SyncHttpApi.history")(function* (ctx: { payload: typeof HistoryPayload.Type }) {
@@ -28,8 +28,8 @@ const commandAliases = {
 export const tuiHandlers = HttpApiBuilder.group(InstanceHttpApi, "tui", (handlers) =>
  Effect.gen(function* () {
    const bus = yield* Bus.Service
-    const publishCommand = (command: typeof TuiEvent.CommandExecute.properties.Type.command | undefined) =>
-      bus.publish(TuiEvent.CommandExecute, { command } as typeof TuiEvent.CommandExecute.properties.Type)
+    const publishCommand = (command: typeof TuiEvent.CommandExecute.properties.Type.command) =>
+      bus.publish(TuiEvent.CommandExecute, { command })

    const appendPrompt = Effect.fn("TuiHttpApi.appendPrompt")(function* (ctx: {
      payload: typeof TuiEvent.PromptAppend.properties.Type
@@ -71,8 +71,7 @@ export const tuiHandlers = HttpApiBuilder.group(InstanceHttpApi, "tui", (handler
    const executeCommand = Effect.fn("TuiHttpApi.executeCommand")(function* (ctx: {
      payload: typeof CommandPayload.Type
    }) {
-      // Legacy only publishes known aliases; unknown commands become undefined.
-      yield* publishCommand(commandAliases[ctx.payload.command as keyof typeof commandAliases])
+      yield* publishCommand(commandAliases[ctx.payload.command as keyof typeof commandAliases] ?? ctx.payload.command)
      return true
    })

@@ -1,57 +1,62 @@
-import { listAdaptors } from "@/control-plane/adaptors"
+import { listAdapters } from "@/control-plane/adapters"
 import { Workspace } from "@/control-plane/workspace"
 import * as InstanceState from "@/effect/instance-state"
+import { Instance } from "@/project/instance"
 import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiError } from "effect/unstable/httpapi"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../api"
 import { CreatePayload, SessionRestorePayload } from "../groups/workspace"

 export const workspaceHandlers = HttpApiBuilder.group(InstanceHttpApi, "workspace", (handlers) =>
  Effect.gen(function* () {
-    const workspace = yield* Workspace.Service
-
-    const adaptors = Effect.fn("WorkspaceHttpApi.adaptors")(function* () {
+    const adapters = Effect.fn("WorkspaceHttpApi.adapters")(function* () {
      const instance = yield* InstanceState.context
-      return yield* Effect.promise(() => listAdaptors(instance.project.id))
+      return yield* Effect.promise(() => listAdapters(instance.project.id))
    })

    const list = Effect.fn("WorkspaceHttpApi.list")(function* () {
-      return yield* workspace.list((yield* InstanceState.context).project)
+      return Workspace.list((yield* InstanceState.context).project)
    })

    const create = Effect.fn("WorkspaceHttpApi.create")(function* (ctx: { payload: typeof CreatePayload.Type }) {
      const instance = yield* InstanceState.context
-      return yield* workspace
-        .create({
-          ...ctx.payload,
-          projectID: instance.project.id,
-        })
-        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          Workspace.create({
+            ...ctx.payload,
+            projectID: instance.project.id,
+          }),
+        ),
+      )
    })

    const status = Effect.fn("WorkspaceHttpApi.status")(function* () {
-      const ids = new Set((yield* workspace.list((yield* InstanceState.context).project)).map((item) => item.id))
-      return (yield* workspace.status()).filter((item) => ids.has(item.workspaceID))
+      const ids = new Set(Workspace.list((yield* InstanceState.context).project).map((item) => item.id))
+      return Workspace.status().filter((item) => ids.has(item.workspaceID))
    })

    const remove = Effect.fn("WorkspaceHttpApi.remove")(function* (ctx: { params: { id: Workspace.Info["id"] } }) {
-      return yield* workspace.remove(ctx.params.id)
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() => Instance.restore(instance, () => Workspace.remove(ctx.params.id)))
    })

    const sessionRestore = Effect.fn("WorkspaceHttpApi.sessionRestore")(function* (ctx: {
      params: { id: Workspace.Info["id"] }
      payload: typeof SessionRestorePayload.Type
    }) {
-      return yield* workspace
-        .sessionRestore({
-          workspaceID: ctx.params.id,
-          sessionID: ctx.payload.sessionID,
-        })
-        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
+      const instance = yield* InstanceState.context
+      return yield* Effect.promise(() =>
+        Instance.restore(instance, () =>
+          Workspace.sessionRestore({
+            workspaceID: ctx.params.id,
+            sessionID: ctx.payload.sessionID,
+          }),
+        ),
+      )
    })

    return handlers
-      .handle("adaptors", adaptors)
+      .handle("adapters", adapters)
      .handle("list", list)
      .handle("create", create)
      .handle("status", status)
@@ -1,63 +1,32 @@
-import type { WorkspaceID } from "@/control-plane/schema"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { WorkspaceRef } from "@/effect/instance-ref"
 import { Instance, type InstanceContext } from "@/project/instance"
 import { Effect } from "effect"
 import { HttpEffect, HttpMiddleware, HttpServerRequest } from "effect/unstable/http"

-type MarkedInstance = {
-  ctx: InstanceContext
-  workspaceID?: WorkspaceID
-}
+const disposeAfterResponse = new WeakMap<object, InstanceContext>()

-// Disposal is requested by an endpoint handler, but must run from the outer
-// server middleware after the response has been produced. The original Request
-// object is the stable handoff key between those two phases.
-const disposeAfterResponse = new WeakMap<object, MarkedInstance>()
-
-const mark = (ctx: InstanceContext) =>
-  Effect.gen(function* () {
-    return { ctx, workspaceID: yield* WorkspaceRef }
-  })
-
-// Instance.dispose/reload still publish events through legacy ALS helpers.
-// Effect request handlers carry these values in services, so bridge them back
-// into the legacy contexts only around the lifecycle operation.
-const restoreMarked = <A>(marked: MarkedInstance, fn: () => A) =>
-  Effect.promise(() =>
-    WorkspaceContext.provide({
-      workspaceID: marked.workspaceID,
-      fn: () => Instance.restore(marked.ctx, fn),
+export const markInstanceForDisposal = (ctx: InstanceContext) =>
+  HttpEffect.appendPreResponseHandler((request, response) =>
+    Effect.sync(() => {
+      disposeAfterResponse.set(request.source, ctx)
+      return response
    }),
  )

-export const markInstanceForDisposal = (ctx: InstanceContext) =>
-  Effect.gen(function* () {
-    const marked = yield* mark(ctx)
-    return yield* HttpEffect.appendPreResponseHandler((request, response) =>
-      Effect.sync(() => {
-        // The response is sent before disposeMiddleware performs the teardown.
-        disposeAfterResponse.set(request.source, marked)
-        return response
-      }),
-    )
-  })
-
 export const markInstanceForReload = (ctx: InstanceContext, next: Parameters<typeof Instance.reload>[0]) =>
-  Effect.gen(function* () {
-    const marked = yield* mark(ctx)
-    return yield* HttpEffect.appendPreResponseHandler((_request, response) =>
-      Effect.as(Effect.uninterruptible(restoreMarked(marked, () => Instance.reload(next))), response),
-    )
-  })
+  HttpEffect.appendPreResponseHandler((_request, response) =>
+    Effect.as(
+      Effect.uninterruptible(Effect.promise(() => Instance.restore(ctx, () => Instance.reload(next)))),
+      response,
+    ),
+  )

 export const disposeMiddleware: HttpMiddleware.HttpMiddleware = (effect) =>
  Effect.gen(function* () {
    const response = yield* effect
    const request = yield* HttpServerRequest.HttpServerRequest
-    const marked = disposeAfterResponse.get(request.source)
-    if (!marked) return response
+    const ctx = disposeAfterResponse.get(request.source)
+    if (!ctx) return response
    disposeAfterResponse.delete(request.source)
-    yield* Effect.uninterruptible(restoreMarked(marked, () => Instance.dispose()))
+    yield* Effect.uninterruptible(Effect.promise(() => Instance.restore(ctx, () => Instance.dispose())))
    return response
  })
@@ -1,63 +1,47 @@
-import { ConfigService } from "@/effect/config-service"
-import { Config, Context, Effect, Encoding, Layer, Option, Redacted } from "effect"
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { HttpApiError, HttpApiMiddleware, HttpApiSecurity } from "effect/unstable/httpapi"
+import { Effect, Encoding, Layer, Redacted, Schema } from "effect"
+import { HttpApiMiddleware, HttpApiSecurity } from "effect/unstable/httpapi"
+import { Flag } from "@opencode-ai/core/flag/flag"

-const AUTH_TOKEN_QUERY = "auth_token"
-const UNAUTHORIZED = 401
+class Unauthorized extends Schema.TaggedErrorClass<Unauthorized>()(
+  "Unauthorized",
+  { message: Schema.String },
+  { httpApiStatus: 401 },
+) {}

 export class Authorization extends HttpApiMiddleware.Service<Authorization>()(
  "@opencode/ExperimentalHttpApiAuthorization",
  {
-    error: HttpApiError.UnauthorizedNoContent,
+    error: Unauthorized,
    security: {
      basic: HttpApiSecurity.basic,
-      authToken: HttpApiSecurity.apiKey({ in: "query", key: AUTH_TOKEN_QUERY }),
+      authToken: HttpApiSecurity.apiKey({ in: "query", key: "auth_token" }),
    },
  },
 ) {}

-export class ServerAuthConfig extends ConfigService.Service<ServerAuthConfig>()(
-  "@opencode/ExperimentalHttpApiServerAuthConfig",
-  {
-    password: Config.string("OPENCODE_SERVER_PASSWORD").pipe(Config.option),
-    username: Config.string("OPENCODE_SERVER_USERNAME").pipe(Config.withDefault("opencode")),
-  },
-) {}
+const emptyCredential = {
+  username: "",
+  password: Redacted.make(""),
+}

 function validateCredential<A, E, R>(
  effect: Effect.Effect<A, E, R>,
-  credential: { readonly username: string; readonly password: Redacted.Redacted },
-  config: Context.Service.Shape<typeof ServerAuthConfig>,
+  credential: { readonly username: string; readonly password: typeof emptyCredential.password },
 ) {
  return Effect.gen(function* () {
-    if (!isAuthRequired(config)) return yield* effect
-    if (!isCredentialAuthorized(credential, config)) return yield* new HttpApiError.Unauthorized({})
+    if (!Flag.OPENCODE_SERVER_PASSWORD) return yield* effect
+
+    if (credential.username !== (Flag.OPENCODE_SERVER_USERNAME ?? "opencode")) {
+      return yield* new Unauthorized({ message: "Unauthorized" })
+    }
+    if (Redacted.value(credential.password) !== Flag.OPENCODE_SERVER_PASSWORD) {
+      return yield* new Unauthorized({ message: "Unauthorized" })
+    }
    return yield* effect
  })
 }

-function isAuthRequired(config: Context.Service.Shape<typeof ServerAuthConfig>) {
-  return Option.isSome(config.password) && config.password.value !== ""
-}
-
-function isCredentialAuthorized(
-  credential: { readonly username: string; readonly password: Redacted.Redacted },
-  config: Context.Service.Shape<typeof ServerAuthConfig>,
-) {
-  return (
-    Option.isSome(config.password) &&
-    credential.username === config.username &&
-    Redacted.value(credential.password) === config.password.value
-  )
-}
-
 function decodeCredential(input: string) {
-  const emptyCredential = {
-    username: "",
-    password: Redacted.make(""),
-  }
-
  return Encoding.decodeBase64String(input)
    .asEffect()
    .pipe(
@@ -75,54 +59,13 @@ function decodeCredential(input: string) {
    )
 }

-function validateRawCredential<A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-  credential: { readonly username: string; readonly password: Redacted.Redacted },
-  config: Context.Service.Shape<typeof ServerAuthConfig>,
-) {
-  if (!isAuthRequired(config)) return effect
-  if (!isCredentialAuthorized(credential, config))
-    return Effect.succeed(HttpServerResponse.empty({ status: UNAUTHORIZED }))
-  return effect
-}
-
-export const authorizationRouterMiddleware = HttpRouter.middleware()(
-  Effect.gen(function* () {
-    const config = yield* ServerAuthConfig
-    if (!isAuthRequired(config)) return (effect) => effect
-
-    return (effect) =>
-      Effect.gen(function* () {
-        const request = yield* HttpServerRequest.HttpServerRequest
-        const match = /^Basic\s+(.+)$/i.exec(request.headers.authorization ?? "")
-        if (match) {
-          return yield* decodeCredential(match[1]).pipe(
-            Effect.flatMap((credential) => validateRawCredential(effect, credential, config)),
-          )
-        }
-
-        const token = new URL(request.url, "http://localhost").searchParams.get(AUTH_TOKEN_QUERY)
-        if (token) {
-          return yield* decodeCredential(token).pipe(
-            Effect.flatMap((credential) => validateRawCredential(effect, credential, config)),
-          )
-        }
-
-        return yield* validateRawCredential(effect, { username: "", password: Redacted.make("") }, config)
-      })
-  }),
-)
-
-export const authorizationLayer = Layer.effect(
+export const authorizationLayer = Layer.succeed(
  Authorization,
-  Effect.gen(function* () {
-    const config = yield* ServerAuthConfig
-    return Authorization.of({
-      basic: (effect, { credential }) => validateCredential(effect, credential, config),
-      authToken: (effect, { credential }) =>
-        decodeCredential(Redacted.value(credential)).pipe(
-          Effect.flatMap((decoded) => validateCredential(effect, decoded, config)),
-        ),
-    })
+  Authorization.of({
+    basic: (effect, { credential }) => validateCredential(effect, credential),
+    authToken: (effect, { credential }) =>
+      Effect.gen(function* () {
+        return yield* validateCredential(effect, yield* decodeCredential(Redacted.value(credential)))
+      }),
  }),
 )
@@ -1,6 +1,13 @@
 import { ProxyUtil } from "@/server/proxy-util"
 import { Effect, Stream } from "effect"
-import { HttpBody, HttpClient, HttpClientRequest, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import {
+  FetchHttpClient,
+  HttpBody,
+  HttpClient,
+  HttpClientRequest,
+  HttpServerRequest,
+  HttpServerResponse,
+} from "effect/unstable/http"
 import * as Socket from "effect/unstable/socket/Socket"

 function webSource(request: HttpServerRequest.HttpServerRequest): Request | undefined {
@@ -59,13 +66,12 @@ function statusText(response: unknown) {
 }

 export function http(
-  client: HttpClient.HttpClient,
  url: string | URL,
  extra: HeadersInit | undefined,
  request: HttpServerRequest.HttpServerRequest,
 ): Effect.Effect<HttpServerResponse.HttpServerResponse> {
  return Effect.gen(function* () {
-    const response = yield* client.execute(
+    const response = yield* HttpClient.execute(
      HttpClientRequest.make(request.method as never)(url, {
        headers: ProxyUtil.headers(request.headers as HeadersInit, extra),
        body: requestBody(request),
@@ -80,7 +86,10 @@ export function http(
      statusText: statusText(response),
      headers,
    })
-  }).pipe(Effect.catch(() => Effect.succeed(HttpServerResponse.empty({ status: 500 }))))
+  }).pipe(
+    Effect.provide(FetchHttpClient.layer),
+    Effect.catch(() => Effect.succeed(HttpServerResponse.empty({ status: 500 }))),
+  )
 }

 export * as HttpApiProxy from "./proxy"
@@ -1,4 +1,4 @@
-import { getAdaptor } from "@/control-plane/adaptors"
+import { getAdapter } from "@/control-plane/adapters"
 import { WorkspaceID } from "@/control-plane/schema"
 import type { Target } from "@/control-plane/types"
 import { Workspace } from "@/control-plane/workspace"
@@ -9,7 +9,7 @@ import * as Fence from "@/server/fence"
 import { getWorkspaceRouteSessionID, isLocalWorkspaceRoute, workspaceProxyURL } from "@/server/workspace"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Context, Data, Effect, Layer } from "effect"
-import { HttpClient, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { HttpApiMiddleware } from "effect/unstable/httpapi"
 import * as Socket from "effect/unstable/socket/Socket"

@@ -75,9 +75,9 @@ function shouldStayOnControlPlane(request: HttpServerRequest.HttpServerRequest,
 function resolveWorkspace(
  id: WorkspaceID | undefined,
  envWorkspaceID: WorkspaceID | undefined,
-): Effect.Effect<Workspace.Info | void, never, Workspace.Service> {
+): Effect.Effect<Workspace.Info | void> {
  if (!id || envWorkspaceID) return Effect.void
-  return Workspace.Service.use((workspace) => workspace.get(id))
+  return Effect.promise(() => Workspace.get(id))
 }

 function missingWorkspaceResponse(id: WorkspaceID): HttpServerResponse.HttpServerResponse {
@@ -89,20 +89,19 @@ function missingWorkspaceResponse(id: WorkspaceID): HttpServerResponse.HttpServe

 function resolveTarget(workspace: Workspace.Info): Effect.Effect<Target> {
  return Effect.gen(function* () {
-    const adaptor = yield* Effect.sync(() => getAdaptor(workspace.projectID, workspace.type))
-    return yield* Effect.promise(() => Promise.resolve(adaptor.target(workspace)))
+    const adapter = yield* Effect.promise(() => getAdapter(workspace.projectID, workspace.type))
+    return yield* Effect.promise(() => Promise.resolve(adapter.target(workspace)))
  })
 }

 function proxyRemote(
-  client: HttpClient.HttpClient,
  request: HttpServerRequest.HttpServerRequest,
  workspace: Workspace.Info,
  target: RemoteTarget,
  url: URL,
-): Effect.Effect<HttpServerResponse.HttpServerResponse, never, Socket.WebSocketConstructor | Workspace.Service> {
+): Effect.Effect<HttpServerResponse.HttpServerResponse, never, Socket.WebSocketConstructor> {
  return Effect.gen(function* () {
-    const syncing = yield* Workspace.Service.use((svc) => svc.isSyncing(workspace.id))
+    const syncing = yield* Effect.promise(() => Workspace.isSyncing(workspace.id))
    if (!syncing) {
      return HttpServerResponse.text(`broken sync connection for workspace: ${workspace.id}`, {
        status: 503,
@@ -112,19 +111,12 @@ function proxyRemote(
    const proxyURL = workspaceProxyURL(target.url, url)
    const headers = request.headers as Record<string, string>
    if (headers["upgrade"]?.toLowerCase() === "websocket") return yield* HttpApiProxy.websocket(request, proxyURL)
-    const response = yield* HttpApiProxy.http(client, proxyURL, target.headers, request)
+    const response = yield* HttpApiProxy.http(proxyURL, target.headers, request)
    const sync = Fence.parse(new Headers(response.headers))
-    if (sync) {
-      const syncFailure = yield* Fence.waitEffect(
-        workspace.id,
-        sync,
-        request.source instanceof Request ? request.source.signal : undefined,
-      ).pipe(
-        Effect.as(undefined),
-        Effect.catch((error) => Effect.succeed(HttpServerResponse.text(error.message, { status: 503 }))),
+    if (sync)
+      yield* Effect.promise(() =>
+        Fence.wait(workspace.id, sync, request.source instanceof Request ? request.source.signal : undefined),
      )
-      if (syncFailure) return syncFailure
-    }
    return response
  })
 }
@@ -133,7 +125,7 @@ function planWorkspaceRequest(
  request: HttpServerRequest.HttpServerRequest,
  url: URL,
  workspace: Workspace.Info,
-): Effect.Effect<RequestPlan, never, Workspace.Service> {
+): Effect.Effect<RequestPlan> {
  return Effect.gen(function* () {
    const target = yield* resolveTarget(workspace)
    if (target.type === "remote") return RequestPlan.Remote({ request, workspace, target, url })
@@ -144,7 +136,7 @@ function planWorkspaceRequest(
 function planRequest(
  request: HttpServerRequest.HttpServerRequest,
  sessionWorkspaceID?: WorkspaceID,
-): Effect.Effect<RequestPlan, never, Workspace.Service> {
+): Effect.Effect<RequestPlan> {
  return Effect.gen(function* () {
    const url = requestURL(request)
    const envWorkspaceID = configuredWorkspaceID()
@@ -164,25 +156,31 @@ function planRequest(
 }

 function routeWorkspace<E>(
-  client: HttpClient.HttpClient,
  effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, WorkspaceRouteContext>,
  plan: RequestPlan,
-): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Socket.WebSocketConstructor | Workspace.Service> {
+): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Socket.WebSocketConstructor> {
  return RequestPlan.$match(plan, {
    MissingWorkspace: ({ workspaceID }) => Effect.succeed(missingWorkspaceResponse(workspaceID)),
-    Remote: ({ request, workspace, target, url }) => proxyRemote(client, request, workspace, target, url),
+    Remote: ({ request, workspace, target, url }) => proxyRemote(request, workspace, target, url),
    Local: ({ directory, workspaceID }) =>
      effect.pipe(Effect.provideService(WorkspaceRouteContext, WorkspaceRouteContext.of({ directory, workspaceID }))),
  })
 }

+function routeWorkspaceRequest<E>(
+  effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, WorkspaceRouteContext>,
+  request: HttpServerRequest.HttpServerRequest,
+  sessionWorkspaceID?: WorkspaceID,
+): Effect.Effect<HttpServerResponse.HttpServerResponse, E, Socket.WebSocketConstructor> {
+  return Effect.flatMap(planRequest(request, sessionWorkspaceID), (plan) => routeWorkspace(effect, plan))
+}
+
 function routeHttpApiWorkspace<E>(
-  client: HttpClient.HttpClient,
  effect: Effect.Effect<HttpServerResponse.HttpServerResponse, E, WorkspaceRouteContext>,
 ): Effect.Effect<
  HttpServerResponse.HttpServerResponse,
  E,
-  Session.Service | Workspace.Service | HttpServerRequest.HttpServerRequest | Socket.WebSocketConstructor
+  Session.Service | HttpServerRequest.HttpServerRequest | Socket.WebSocketConstructor
 > {
  return Effect.gen(function* () {
    const request = yield* HttpServerRequest.HttpServerRequest
@@ -190,8 +188,7 @@ function routeHttpApiWorkspace<E>(
    const session = sessionID
      ? yield* Session.Service.use((svc) => svc.get(sessionID)).pipe(Effect.catchDefect(() => Effect.void))
      : undefined
-    const plan = yield* planRequest(request, session?.workspaceID)
-    return yield* routeWorkspace(client, effect, plan)
+    return yield* routeWorkspaceRequest(effect, request, session?.workspaceID)
  })
 }

@@ -199,13 +196,8 @@ export const workspaceRoutingLayer = Layer.effect(
  WorkspaceRoutingMiddleware,
  Effect.gen(function* () {
    const makeWebSocket = yield* Socket.WebSocketConstructor
-    const workspace = yield* Workspace.Service
-    const client = yield* HttpClient.HttpClient
    return WorkspaceRoutingMiddleware.of((effect) =>
-      routeHttpApiWorkspace(client, effect).pipe(
-        Effect.provideService(Socket.WebSocketConstructor, makeWebSocket),
-        Effect.provideService(Workspace.Service, workspace),
-      ),
+      routeHttpApiWorkspace(effect).pipe(Effect.provideService(Socket.WebSocketConstructor, makeWebSocket)),
    )
  }),
 )
@@ -213,16 +205,12 @@ export const workspaceRoutingLayer = Layer.effect(
 export const workspaceRouterMiddleware = HttpRouter.middleware<{ provides: WorkspaceRouteContext }>()(
  Effect.gen(function* () {
    const makeWebSocket = yield* Socket.WebSocketConstructor
-    const workspace = yield* Workspace.Service
-    const client = yield* HttpClient.HttpClient
    return (effect) =>
      Effect.gen(function* () {
        const request = yield* HttpServerRequest.HttpServerRequest
-        const plan = yield* planRequest(request)
-        return yield* routeWorkspace(client, effect, plan)
-      }).pipe(
-        Effect.provideService(Socket.WebSocketConstructor, makeWebSocket),
-        Effect.provideService(Workspace.Service, workspace),
-      )
+        return yield* routeWorkspaceRequest(effect, request).pipe(
+          Effect.provideService(Socket.WebSocketConstructor, makeWebSocket),
+        )
+      })
  }),
 )
@@ -1,8 +1,7 @@
 import { Context, Effect, Layer } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { FetchHttpClient, HttpClient, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
 import * as Socket from "effect/unstable/socket/Socket"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Account } from "@/account/account"
 import { Agent } from "@/agent/agent"
 import { Auth } from "@/auth"
@@ -23,26 +22,18 @@ import { Provider } from "@/provider/provider"
 import { Pty } from "@/pty"
 import { Question } from "@/question"
 import { Session } from "@/session/session"
-import { SessionCompaction } from "@/session/compaction"
-import { SessionPrompt } from "@/session/prompt"
-import { SessionRevert } from "@/session/revert"
 import { SessionRunState } from "@/session/run-state"
 import { SessionStatus } from "@/session/status"
 import { SessionSummary } from "@/session/summary"
 import { Todo } from "@/session/todo"
-import { SessionShare } from "@/share/session"
 import { Skill } from "@/skill"
-import { SyncEvent } from "@/sync"
 import { ToolRegistry } from "@/tool/registry"
 import { lazy } from "@/util/lazy"
 import { Vcs } from "@/project/vcs"
 import { Worktree } from "@/worktree"
-import { Workspace } from "@/control-plane/workspace"
-import { isAllowedCorsOrigin } from "@/server/cors"
-import { serveUIEffect } from "@/server/routes/ui"
 import { InstanceHttpApi, RootHttpApi } from "./api"
-import { ServerAuthConfig, authorizationLayer, authorizationRouterMiddleware } from "./middleware/authorization"
-import { EventApi, eventHandlers } from "./event"
+import { authorizationLayer } from "./middleware/authorization"
+import { eventRoute } from "./event"
 import { configHandlers } from "./handlers/config"
 import { controlHandlers } from "./handlers/control"
 import { experimentalHandlers } from "./handlers/experimental"
@@ -65,7 +56,7 @@ import { disposeMiddleware } from "./lifecycle"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"
 import * as ServerBackend from "@/server/backend"

-export const context = Context.makeUnsafe<unknown>(new Map())
+export const context = Context.empty() as Context.Context<unknown>

 const runtime = HttpRouter.middleware()(
  Effect.succeed((effect) =>
@@ -77,23 +68,7 @@ const runtime = HttpRouter.middleware()(
  ),
 ).layer

-const cors = HttpRouter.middleware(
-  HttpMiddleware.cors({
-    allowedOrigins: isAllowedCorsOrigin,
-    maxAge: 86_400,
-  }),
-  { global: true },
-)
-
 const rootApiRoutes = HttpApiBuilder.layer(RootHttpApi).pipe(Layer.provide([controlHandlers, globalHandlers]))
-const instanceRouterLayer = authorizationRouterMiddleware
-  .combine(instanceRouterMiddleware)
-  .combine(workspaceRouterMiddleware)
-  .layer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal), Layer.provide(ServerAuthConfig.defaultLayer))
-const eventApiRoutes = HttpApiBuilder.layer(EventApi).pipe(
-  Layer.provide(eventHandlers),
-  Layer.provide(instanceRouterLayer),
-)
 const instanceApiRoutes = HttpApiBuilder.layer(InstanceHttpApi).pipe(
  Layer.provide([
    configHandlers,
@@ -113,26 +88,23 @@ const instanceApiRoutes = HttpApiBuilder.layer(InstanceHttpApi).pipe(
  ]),
 )

-const rawInstanceRoutes = Layer.mergeAll(ptyConnectRoute).pipe(Layer.provide(instanceRouterLayer))
+const rawInstanceRoutes = Layer.mergeAll(eventRoute, ptyConnectRoute).pipe(
+  Layer.provide(
+    instanceRouterMiddleware
+      .combine(workspaceRouterMiddleware)
+      .layer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)),
+  ),
+)
 const instanceRoutes = Layer.mergeAll(rawInstanceRoutes, instanceApiRoutes).pipe(
  Layer.provide([
-    authorizationLayer.pipe(Layer.provide(ServerAuthConfig.defaultLayer)),
+    authorizationLayer,
    workspaceRoutingLayer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)),
    instanceContextLayer,
  ]),
 )

-const uiRoute = HttpRouter.use((router) =>
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const client = yield* HttpClient.HttpClient
-    yield* router.add("*", "/*", (request) => serveUIEffect(request, { fs, client }))
-  }),
-).pipe(Layer.provide(authorizationRouterMiddleware.layer.pipe(Layer.provide(ServerAuthConfig.defaultLayer))))
-
-export const routes = Layer.mergeAll(rootApiRoutes, eventApiRoutes, instanceRoutes, uiRoute).pipe(
+export const routes = Layer.mergeAll(rootApiRoutes, instanceRoutes).pipe(
  Layer.provide([
-    cors,
    runtime,
    Account.defaultLayer,
    Agent.defaultLayer,
@@ -152,23 +124,15 @@ export const routes = Layer.mergeAll(rootApiRoutes, eventApiRoutes, instanceRout
    Question.defaultLayer,
    Ripgrep.defaultLayer,
    Session.defaultLayer,
-    SessionCompaction.defaultLayer,
-    SessionPrompt.defaultLayer,
-    SessionRevert.defaultLayer,
-    SessionShare.defaultLayer,
    SessionRunState.defaultLayer,
    SessionStatus.defaultLayer,
    SessionSummary.defaultLayer,
-    SyncEvent.defaultLayer,
    Skill.defaultLayer,
    Todo.defaultLayer,
    ToolRegistry.defaultLayer,
    Vcs.defaultLayer,
-    Workspace.defaultLayer,
    Worktree.defaultLayer,
    Bus.layer,
-    AppFileSystem.defaultLayer,
-    FetchHttpClient.layer,
    HttpServer.layerServices,
  ]),
  Layer.provideMerge(Observability.layer),
@@ -12,8 +12,7 @@ import { eq } from "drizzle-orm"
 import { EventTable } from "@/sync/event.sql"
 import { lazy } from "@/util/lazy"
 import * as Log from "@opencode-ai/core/util/log"
-import { Workspace } from "@/control-plane/workspace"
-import { AppRuntime } from "@/effect/app-runtime"
+import { startWorkspaceSyncing } from "@/control-plane/workspace"
 import { Instance } from "@/project/instance"
 import { errors } from "../../error"

@@ -47,9 +46,7 @@ export const SyncRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        void AppRuntime.runPromise(
-          Workspace.Service.use((workspace) => workspace.startWorkspaceSyncing(Instance.project.id)),
-        )
+        startWorkspaceSyncing(Instance.project.id)
        return c.json(true)
      },
    )
@@ -94,7 +91,7 @@ export const SyncRoutes = lazy(() =>
          last: events.at(-1)?.seq,
          directory: body.directory,
        })
-        await AppRuntime.runPromise(SyncEvent.use.replayAll(events))
+        SyncEvent.replayAll(events)

        log.info("sync replay complete", {
          sessionID: source,
@@ -1,13 +1,9 @@
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Effect, Stream } from "effect"
-import { HttpBody, HttpClient, HttpClientRequest, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { Hono } from "hono"
 import { proxy } from "hono/proxy"
 import { getMimeType } from "hono/utils/mime"
 import { createHash } from "node:crypto"
 import fs from "node:fs/promises"
-import { ProxyUtil } from "../proxy-util"

 const embeddedUIPromise = Flag.OPENCODE_DISABLE_EMBEDDED_WEB_UI
  ? Promise.resolve(null)
@@ -16,112 +12,44 @@ const embeddedUIPromise = Flag.OPENCODE_DISABLE_EMBEDDED_WEB_UI

 const DEFAULT_CSP =
  "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:"
-const UI_UPSTREAM = new URL("https://app.opencode.ai")

 const csp = (hash = "") =>
  `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`

-function themePreloadHash(body: string) {
-  return body.match(/<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i)
-}
-
-function requestBody(request: HttpServerRequest.HttpServerRequest) {
-  if (request.method === "GET" || request.method === "HEAD") return HttpBody.empty
-  const len = request.headers["content-length"]
-  return HttpBody.stream(request.stream, request.headers["content-type"], len === undefined ? undefined : Number(len))
-}
-
-function proxyResponseHeaders(headers: Record<string, string>) {
-  const result = new Headers(headers)
-  // FetchHttpClient exposes decoded response bodies, so forwarding upstream
-  // transfer metadata makes browsers decode already-decoded assets again.
-  result.delete("content-encoding")
-  result.delete("content-length")
-  return result
-}
-
-function upstreamURL(path: string) {
-  return new URL(path, UI_UPSTREAM).toString()
-}
-
-function embeddedUI() {
-  if (Flag.OPENCODE_DISABLE_EMBEDDED_WEB_UI) return Promise.resolve(null)
-  return embeddedUIPromise
-}
-
-export async function serveUI(request: Request) {
-  const embeddedWebUI = await embeddedUI()
-  const path = new URL(request.url).pathname
-
-  if (embeddedWebUI) {
-    const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
-    if (!match) return Response.json({ error: "Not Found" }, { status: 404 })
-
-    if (await fs.exists(match)) {
-      const mime = getMimeType(match) ?? "text/plain"
-      const headers = new Headers({ "content-type": mime })
-      if (mime.startsWith("text/html")) headers.set("content-security-policy", DEFAULT_CSP)
-      return new Response(new Uint8Array(await fs.readFile(match)), { headers })
-    }
-
-    return Response.json({ error: "Not Found" }, { status: 404 })
-  }
-
-  const response = await proxy(upstreamURL(path), {
-    raw: request,
-    headers: ProxyUtil.headers(request, { host: UI_UPSTREAM.host }),
-  })
-  const match = response.headers.get("content-type")?.includes("text/html")
-    ? themePreloadHash(await response.clone().text())
-    : undefined
-  const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
-  response.headers.set("Content-Security-Policy", csp(hash))
-  return response
-}
-
-export function serveUIEffect(
-  request: HttpServerRequest.HttpServerRequest,
-  services: { fs: AppFileSystem.Interface; client: HttpClient.HttpClient },
-) {
-  return Effect.gen(function* () {
-    const embeddedWebUI = yield* Effect.promise(() => embeddedUI())
-    const path = new URL(request.url, "http://localhost").pathname
+export const UIRoutes = (): Hono =>
+  new Hono().all("/*", async (c) => {
+    const embeddedWebUI = await embeddedUIPromise
+    const path = c.req.path

    if (embeddedWebUI) {
      const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
-      if (!match) return HttpServerResponse.jsonUnsafe({ error: "Not Found" }, { status: 404 })
+      if (!match) return c.json({ error: "Not Found" }, 404)

-      if (yield* services.fs.existsSafe(match)) {
+      if (await fs.exists(match)) {
        const mime = getMimeType(match) ?? "text/plain"
-        const headers = new Headers({ "content-type": mime })
-        if (mime.startsWith("text/html")) headers.set("content-security-policy", DEFAULT_CSP)
-        return HttpServerResponse.raw(yield* services.fs.readFile(match), { headers })
+        c.header("Content-Type", mime)
+        if (mime.startsWith("text/html")) {
+          c.header("Content-Security-Policy", DEFAULT_CSP)
+        }
+        return c.body(new Uint8Array(await fs.readFile(match)))
+      } else {
+        return c.json({ error: "Not Found" }, 404)
      }
-
-      return HttpServerResponse.jsonUnsafe({ error: "Not Found" }, { status: 404 })
+    } else {
+      const response = await proxy(`https://app.opencode.ai${path}`, {
+        raw: c.req.raw,
+        headers: {
+          ...Object.fromEntries(c.req.raw.headers.entries()),
+          host: "app.opencode.ai",
+        },
+      })
+      const match = response.headers.get("content-type")?.includes("text/html")
+        ? (await response.clone().text()).match(
+            /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i,
+          )
+        : undefined
+      const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
+      response.headers.set("Content-Security-Policy", csp(hash))
+      return response
    }
-
-    const response = yield* services.client.execute(
-      HttpClientRequest.make(request.method)(upstreamURL(path), {
-        headers: ProxyUtil.headers(request.headers, { host: UI_UPSTREAM.host }),
-        body: requestBody(request),
-      }),
-    )
-    const headers = proxyResponseHeaders(response.headers)
-
-    if (response.headers["content-type"]?.includes("text/html")) {
-      const body = yield* response.text
-      const match = themePreloadHash(body)
-      headers.set("Content-Security-Policy", csp(match ? createHash("sha256").update(match[2]).digest("base64") : ""))
-      return HttpServerResponse.text(body, { status: response.status, headers })
-    }
-
-    headers.set("Content-Security-Policy", csp())
-    return HttpServerResponse.stream(response.stream.pipe(Stream.catchCause(() => Stream.empty)), {
-      status: response.status,
-      headers,
-    })
  })
-}
-
-export const UIRoutes = (): Hono => new Hono().all("/*", (c) => serveUI(c.req.raw))
@@ -1,6 +1,6 @@
 import type { MiddlewareHandler } from "hono"
 import type { UpgradeWebSocket } from "hono/ws"
-import { getAdaptor } from "@/control-plane/adaptors"
+import { getAdapter } from "@/control-plane/adapters"
 import { WorkspaceID } from "@/control-plane/schema"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
 import { Workspace } from "@/control-plane/workspace"
@@ -17,7 +17,6 @@ import { ServerProxy } from "./proxy"
 type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }

 const RULES: Array<Rule> = [
-  { path: "/experimental/workspace", action: "local" },
  { path: "/session/status", action: "forward" },
  { method: "GET", path: "/session", action: "local" },
 ]
@@ -72,9 +71,7 @@ export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): Middleware
      return next()
    }

-    const workspace = await AppRuntime.runPromise(
-      Workspace.Service.use((svc) => svc.get(WorkspaceID.make(workspaceID))),
-    )
+    const workspace = await Workspace.get(WorkspaceID.make(workspaceID))

    if (!workspace) {
      return new Response(`Workspace not found: ${workspaceID}`, {
@@ -91,8 +88,8 @@ export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): Middleware
      return next()
    }

-    const adaptor = getAdaptor(workspace.projectID, workspace.type)
-    const target = await adaptor.target(workspace)
+    const adapter = await getAdapter(workspace.projectID, workspace.type)
+    const target = await adapter.target(workspace)

    if (target.type === "local") {
      return WorkspaceContext.provide({
@@ -1,3 +1,4 @@
+import os from "os"
 import path from "path"
 import { Effect, Layer, Context } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
@@ -7,15 +8,30 @@ import { Flag } from "@opencode-ai/core/flag/flag"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { withTransientReadRetry } from "@/util/effect-http-client"
 import { Global } from "@opencode-ai/core/global"
+import * as Log from "@opencode-ai/core/util/log"
 import type { MessageV2 } from "./message-v2"
 import type { MessageID } from "./schema"

+const log = Log.create({ service: "instruction" })
+
 const FILES = [
  "AGENTS.md",
  ...(Flag.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT ? [] : ["CLAUDE.md"]),
  "CONTEXT.md", // deprecated
 ]

+function globalFiles() {
+  const files = []
+  if (Flag.OPENCODE_CONFIG_DIR) {
+    files.push(path.join(Flag.OPENCODE_CONFIG_DIR, "AGENTS.md"))
+  }
+  files.push(path.join(Global.Path.config, "AGENTS.md"))
+  if (!Flag.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT) {
+    files.push(path.join(os.homedir(), ".claude", "CLAUDE.md"))
+  }
+  return files
+}
+
 function extract(messages: MessageV2.WithParts[]) {
  const paths = new Set<string>()
  for (const msg of messages) {
@@ -47,180 +63,176 @@ export interface Interface {

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

-export const layer: Layer.Layer<
-  Service,
-  never,
-  AppFileSystem.Service | Config.Service | Global.Service | HttpClient.HttpClient
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const cfg = yield* Config.Service
-    const fs = yield* AppFileSystem.Service
-    const global = yield* Global.Service
-    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
-    const globalFiles = [
-      path.join(global.config, "AGENTS.md"),
-      ...(!Flag.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
-    ]
+export const layer: Layer.Layer<Service, never, AppFileSystem.Service | Config.Service | HttpClient.HttpClient> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const cfg = yield* Config.Service
+      const fs = yield* AppFileSystem.Service
+      const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))

-    const state = yield* InstanceState.make(
-      Effect.fn("Instruction.state")(() =>
-        Effect.succeed({
-          // Track which instruction files have already been attached for a given assistant message.
-          claims: new Map<MessageID, Set<string>>(),
-        }),
-      ),
-    )
-
-    const relative = Effect.fnUntraced(function* (instruction: string) {
-      const ctx = yield* InstanceState.context
-      if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
-        return yield* fs
-          .globUp(instruction, ctx.directory, ctx.worktree)
-          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
-      }
-      return yield* fs
-        .globUp(instruction, global.config, global.config)
-        .pipe(Effect.catch(() => Effect.succeed([] as string[])))
-    })
-
-    const read = Effect.fnUntraced(function* (filepath: string) {
-      return yield* fs.readFileString(filepath).pipe(Effect.catch(() => Effect.succeed("")))
-    })
-
-    const fetch = Effect.fnUntraced(function* (url: string) {
-      const res = yield* http.execute(HttpClientRequest.get(url)).pipe(
-        Effect.timeout(5000),
-        Effect.catch(() => Effect.succeed(null)),
+      const state = yield* InstanceState.make(
+        Effect.fn("Instruction.state")(() =>
+          Effect.succeed({
+            // Track which instruction files have already been attached for a given assistant message.
+            claims: new Map<MessageID, Set<string>>(),
+          }),
+        ),
      )
-      if (!res) return ""
-      const body = yield* res.arrayBuffer.pipe(Effect.catch(() => Effect.succeed(new ArrayBuffer(0))))
-      return new TextDecoder().decode(body)
-    })

-    const clear = Effect.fn("Instruction.clear")(function* (messageID: MessageID) {
-      const s = yield* InstanceState.get(state)
-      s.claims.delete(messageID)
-    })
-
-    const systemPaths = Effect.fn("Instruction.systemPaths")(function* () {
-      const config = yield* cfg.get()
-      const ctx = yield* InstanceState.context
-      const paths = new Set<string>()
-
-      for (const file of globalFiles) {
-        if (yield* fs.existsSafe(file)) {
-          paths.add(path.resolve(file))
-          break
+      const relative = Effect.fnUntraced(function* (instruction: string) {
+        const ctx = yield* InstanceState.context
+        if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+          return yield* fs
+            .globUp(instruction, ctx.directory, ctx.worktree)
+            .pipe(Effect.catch(() => Effect.succeed([] as string[])))
        }
-      }
+        if (!Flag.OPENCODE_CONFIG_DIR) {
+          log.warn(
+            `Skipping relative instruction "${instruction}" - no OPENCODE_CONFIG_DIR set while project config is disabled`,
+          )
+          return []
+        }
+        return yield* fs
+          .globUp(instruction, Flag.OPENCODE_CONFIG_DIR, Flag.OPENCODE_CONFIG_DIR)
+          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      })

-      // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
-      if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
-        for (const file of FILES) {
-          const matches = yield* fs.findUp(file, ctx.directory, ctx.worktree)
-          if (matches.length > 0) {
-            matches.forEach((item) => paths.add(path.resolve(item)))
+      const read = Effect.fnUntraced(function* (filepath: string) {
+        return yield* fs.readFileString(filepath).pipe(Effect.catch(() => Effect.succeed("")))
+      })
+
+      const fetch = Effect.fnUntraced(function* (url: string) {
+        const res = yield* http.execute(HttpClientRequest.get(url)).pipe(
+          Effect.timeout(5000),
+          Effect.catch(() => Effect.succeed(null)),
+        )
+        if (!res) return ""
+        const body = yield* res.arrayBuffer.pipe(Effect.catch(() => Effect.succeed(new ArrayBuffer(0))))
+        return new TextDecoder().decode(body)
+      })
+
+      const clear = Effect.fn("Instruction.clear")(function* (messageID: MessageID) {
+        const s = yield* InstanceState.get(state)
+        s.claims.delete(messageID)
+      })
+
+      const systemPaths = Effect.fn("Instruction.systemPaths")(function* () {
+        const config = yield* cfg.get()
+        const ctx = yield* InstanceState.context
+        const paths = new Set<string>()
+
+        for (const file of globalFiles()) {
+          if (yield* fs.existsSafe(file)) {
+            paths.add(path.resolve(file))
            break
          }
        }
-      }

-      if (config.instructions) {
-        for (const raw of config.instructions) {
-          if (raw.startsWith("https://") || raw.startsWith("http://")) continue
-          const instruction = raw.startsWith("~/") ? path.join(global.home, raw.slice(2)) : raw
-          const matches = yield* (
-            path.isAbsolute(instruction)
-              ? fs.glob(path.basename(instruction), {
-                  cwd: path.dirname(instruction),
-                  absolute: true,
-                  include: "file",
-                })
-              : relative(instruction)
-          ).pipe(Effect.catch(() => Effect.succeed([] as string[])))
-          matches.forEach((item) => paths.add(path.resolve(item)))
+        // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
+        if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
+          for (const file of FILES) {
+            const matches = yield* fs.findUp(file, ctx.directory, ctx.worktree)
+            if (matches.length > 0) {
+              matches.forEach((item) => paths.add(path.resolve(item)))
+              break
+            }
+          }
        }
-      }

-      return paths
-    })
+        if (config.instructions) {
+          for (const raw of config.instructions) {
+            if (raw.startsWith("https://") || raw.startsWith("http://")) continue
+            const instruction = raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw
+            const matches = yield* (
+              path.isAbsolute(instruction)
+                ? fs.glob(path.basename(instruction), {
+                    cwd: path.dirname(instruction),
+                    absolute: true,
+                    include: "file",
+                  })
+                : relative(instruction)
+            ).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+            matches.forEach((item) => paths.add(path.resolve(item)))
+          }
+        }

-    const system = Effect.fn("Instruction.system")(function* () {
-      const config = yield* cfg.get()
-      const paths = yield* systemPaths()
-      const urls = (config.instructions ?? []).filter(
-        (item) => item.startsWith("https://") || item.startsWith("http://"),
-      )
+        return paths
+      })

-      const files = yield* Effect.forEach(Array.from(paths), read, { concurrency: 8 })
-      const remote = yield* Effect.forEach(urls, fetch, { concurrency: 4 })
+      const system = Effect.fn("Instruction.system")(function* () {
+        const config = yield* cfg.get()
+        const paths = yield* systemPaths()
+        const urls = (config.instructions ?? []).filter(
+          (item) => item.startsWith("https://") || item.startsWith("http://"),
+        )

-      return [
-        ...Array.from(paths).flatMap((item, i) => (files[i] ? [`Instructions from: ${item}\n${files[i]}`] : [])),
-        ...urls.flatMap((item, i) => (remote[i] ? [`Instructions from: ${item}\n${remote[i]}`] : [])),
-      ]
-    })
+        const files = yield* Effect.forEach(Array.from(paths), read, { concurrency: 8 })
+        const remote = yield* Effect.forEach(urls, fetch, { concurrency: 4 })

-    const find = Effect.fn("Instruction.find")(function* (dir: string) {
-      for (const file of FILES) {
-        const filepath = path.resolve(path.join(dir, file))
-        if (yield* fs.existsSafe(filepath)) return filepath
-      }
-      return undefined
-    })
+        return [
+          ...Array.from(paths).flatMap((item, i) => (files[i] ? [`Instructions from: ${item}\n${files[i]}`] : [])),
+          ...urls.flatMap((item, i) => (remote[i] ? [`Instructions from: ${item}\n${remote[i]}`] : [])),
+        ]
+      })

-    const resolve = Effect.fn("Instruction.resolve")(function* (
-      messages: MessageV2.WithParts[],
-      filepath: string,
-      messageID: MessageID,
-    ) {
-      const sys = yield* systemPaths()
-      const already = extract(messages)
-      const results: { filepath: string; content: string }[] = []
-      const s = yield* InstanceState.get(state)
-      const root = path.resolve(yield* InstanceState.directory)
+      const find = Effect.fn("Instruction.find")(function* (dir: string) {
+        for (const file of FILES) {
+          const filepath = path.resolve(path.join(dir, file))
+          if (yield* fs.existsSafe(filepath)) return filepath
+        }
+      })

-      const target = path.resolve(filepath)
-      let current = path.dirname(target)
+      const resolve = Effect.fn("Instruction.resolve")(function* (
+        messages: MessageV2.WithParts[],
+        filepath: string,
+        messageID: MessageID,
+      ) {
+        const sys = yield* systemPaths()
+        const already = extract(messages)
+        const results: { filepath: string; content: string }[] = []
+        const s = yield* InstanceState.get(state)
+        const root = path.resolve(yield* InstanceState.directory)
+
+        const target = path.resolve(filepath)
+        let current = path.dirname(target)
+
+        // Walk upward from the file being read and attach nearby instruction files once per message.
+        while (current.startsWith(root) && current !== root) {
+          const found = yield* find(current)
+          if (!found || found === target || sys.has(found) || already.has(found)) {
+            current = path.dirname(current)
+            continue
+          }
+
+          let set = s.claims.get(messageID)
+          if (!set) {
+            set = new Set()
+            s.claims.set(messageID, set)
+          }
+          if (set.has(found)) {
+            current = path.dirname(current)
+            continue
+          }
+
+          set.add(found)
+          const content = yield* read(found)
+          if (content) {
+            results.push({ filepath: found, content: `Instructions from: ${found}\n${content}` })
+          }

-      // Walk upward from the file being read and attach nearby instruction files once per message.
-      while (current.startsWith(root) && current !== root) {
-        const found = yield* find(current)
-        if (!found || found === target || sys.has(found) || already.has(found)) {
          current = path.dirname(current)
-          continue
        }

-        let set = s.claims.get(messageID)
-        if (!set) {
-          set = new Set()
-          s.claims.set(messageID, set)
-        }
-        if (set.has(found)) {
-          current = path.dirname(current)
-          continue
-        }
+        return results
+      })

-        set.add(found)
-        const content = yield* read(found)
-        if (content) {
-          results.push({ filepath: found, content: `Instructions from: ${found}\n${content}` })
-        }
-
-        current = path.dirname(current)
-      }
-
-      return results
-    })
-
-    return Service.of({ clear, systemPaths, system, find, resolve })
-  }),
-)
+      return Service.of({ clear, systemPaths, system, find, resolve })
+    }),
+  )

 export const defaultLayer = layer.pipe(
  Layer.provide(Config.defaultLayer),
-  Layer.provide(Global.layer),
  Layer.provide(AppFileSystem.defaultLayer),
  Layer.provide(FetchHttpClient.layer),
 )
@@ -7,7 +7,7 @@ import { mergeDeep, pipe } from "remeda"
 import { GitLabWorkflowLanguageModel } from "gitlab-ai-provider"
 import { ProviderTransform } from "@/provider/transform"
 import { Config } from "@/config/config"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "@/project/instance"
 import type { Agent } from "@/agent/agent"
 import type { MessageV2 } from "./message-v2"
 import { Plugin } from "@/plugin"
@@ -268,7 +268,7 @@ const live: Layer.Layer<

        const bridge = yield* EffectBridge.make()
        const approvedToolsForSession = new Set<string>()
-        workflowModel.approvalHandler = InstanceState.bind(async (approvalTools) => {
+        workflowModel.approvalHandler = Instance.bind(async (approvalTools) => {
          const uniqueNames = [...new Set(approvalTools.map((t: { name: string }) => t.name))] as string[]
          // Auto-approve tools that were already approved in this session
          // (prevents infinite approval loops for server-side MCP tools)
@@ -330,10 +330,6 @@ const live: Layer.Layer<
          })
        : undefined

-      const opencodeProjectID = input.model.providerID.startsWith("opencode")
-        ? (yield* InstanceState.context).project.id
-        : undefined
-
      return streamText({
        onError(error) {
          l.error("stream error", {
@@ -373,7 +369,7 @@ const live: Layer.Layer<
        headers: {
          ...(input.model.providerID.startsWith("opencode")
            ? {
-                "x-opencode-project": opencodeProjectID,
+                "x-opencode-project": Instance.project.id,
                "x-opencode-session": input.sessionID,
                "x-opencode-request": input.user.id,
                "x-opencode-client": Flag.OPENCODE_CLIENT,
@@ -45,7 +45,7 @@ import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { Truncate } from "@/tool/truncate"
 import { decodeDataUrl } from "@/util/data-url"
 import { Process } from "@/util/process"
-import { Cause, Effect, Exit, Latch, Layer, Option, Scope, Context, Schema, Types } from "effect"
+import { Cause, Effect, Exit, Latch, Layer, Option, Scope, Context, Schema } from "effect"
 import { zod } from "@/util/effect-zod"
 import { withStatics } from "@/util/schema"
 import * as EffectLogger from "@opencode-ai/core/effect/logger"
@@ -127,7 +127,7 @@ export const layer = Layer.effect(

    const resolvePromptParts = Effect.fn("SessionPrompt.resolvePromptParts")(function* (template: string) {
      const ctx = yield* InstanceState.context
-      const parts: Types.DeepMutable<PromptInput["parts"]> = [{ type: "text", text: template }]
+      const parts: PromptInput["parts"] = [{ type: "text", text: template }]
      const files = ConfigMarkdown.files(template)
      const seen = new Set<string>()
      yield* Effect.forEach(
@@ -256,8 +256,7 @@ export const layer = Layer.effect(

      const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
      if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
-        const ctx = yield* InstanceState.context
-        const plan = Session.plan(input.session, ctx)
+        const plan = Session.plan(input.session)
        if (!(yield* fsys.existsSafe(plan))) return input.messages
        const part = yield* sessions.updatePart({
          id: PartID.ascending(),
@@ -273,8 +272,7 @@ export const layer = Layer.effect(

      if (input.agent.name !== "plan" || assistantMessage?.info.agent === "plan") return input.messages

-      const ctx = yield* InstanceState.context
-      const plan = Session.plan(input.session, ctx)
+      const plan = Session.plan(input.session)
      const exists = yield* fsys.existsSafe(plan)
      if (!exists) yield* fsys.ensureDir(path.dirname(plan)).pipe(Effect.catch(Effect.die))
      const part = yield* sessions.updatePart({
@@ -1014,7 +1012,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
            case "file:": {
              log.info("file", { mime: part.mime })
              const filepath = fileURLToPath(part.url)
-              const mime = (yield* fsys.isDir(filepath)) ? "application/x-directory" : part.mime
+              if (yield* fsys.isDir(filepath)) part.mime = "application/x-directory"

              const { read } = yield* registry.named()
              const execRead = (args: Parameters<typeof read.execute>[0], extra?: Tool.Context["extra"]) => {
@@ -1033,7 +1031,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                  .pipe(Effect.onInterrupt(() => Effect.sync(() => controller.abort())))
              }

-              if (mime === "text/plain") {
+              if (part.mime === "text/plain") {
                let offset: number | undefined
                let limit: number | undefined
                const range = { start: url.searchParams.get("start"), end: url.searchParams.get("end") }
@@ -1091,7 +1089,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                      })),
                    )
                  } else {
-                    pieces.push({ ...part, mime, messageID: info.id, sessionID: input.sessionID })
+                    pieces.push({ ...part, messageID: info.id, sessionID: input.sessionID })
                  }
                } else {
                  const error = Cause.squash(exit.cause)
@@ -1112,7 +1110,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                return pieces
              }

-              if (mime === "application/x-directory") {
+              if (part.mime === "application/x-directory") {
                const args = { filePath: filepath }
                const exit = yield* execRead(args).pipe(Effect.exit)
                if (Exit.isFailure(exit)) {
@@ -1148,7 +1146,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                    synthetic: true,
                    text: exit.value.output,
                  },
-                  { ...part, mime, messageID: info.id, sessionID: input.sessionID },
+                  { ...part, messageID: info.id, sessionID: input.sessionID },
                ]
              }

@@ -1166,9 +1164,9 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                  sessionID: input.sessionID,
                  type: "file",
                  url:
-                    `data:${mime};base64,` +
+                    `data:${part.mime};base64,` +
                    Buffer.from(yield* fsys.readFile(filepath).pipe(Effect.catch(Effect.die))).toString("base64"),
-                  mime,
+                  mime: part.mime,
                  filename: part.filename!,
                  source: part.source,
                },
@@ -1702,7 +1700,18 @@ export const PromptInput = Schema.Struct({
    ]).annotate({ discriminator: "type" }),
  ),
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type PromptInput = Schema.Schema.Type<typeof PromptInput>
+// `z.discriminatedUnion` erases the discriminated members' shapes back to
+// `{}` when walked from the generic `z.ZodType` input. Restore the precise
+// `parts` type from the exported Schema input types so callers see a proper
+// tagged union.
+type PartInputUnion =
+  | MessageV2.TextPartInput
+  | MessageV2.FilePartInput
+  | MessageV2.AgentPartInput
+  | MessageV2.SubtaskPartInput
+export type PromptInput = Omit<Schema.Schema.Type<typeof PromptInput>, "parts"> & {
+  parts: PartInputUnion[]
+}

 export class LoopInput extends Schema.Class<LoopInput>("SessionPrompt.LoopInput")({
  sessionID: SessionID,
@@ -38,7 +38,6 @@ export const layer = Layer.effect(
    const bus = yield* Bus.Service
    const summary = yield* SessionSummary.Service
    const state = yield* SessionRunState.Service
-    const sync = yield* SyncEvent.Service

    const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
      yield* state.assertNotBusy(input.sessionID)
@@ -122,7 +121,7 @@ export const layer = Layer.effect(
        remove.push(msg)
      }
      for (const msg of remove) {
-        yield* sync.run(MessageV2.Event.Removed, {
+        SyncEvent.run(MessageV2.Event.Removed, {
          sessionID,
          messageID: msg.info.id,
        })
@@ -134,7 +133,7 @@ export const layer = Layer.effect(
          const removeParts = target.parts.slice(idx)
          target.parts = target.parts.slice(0, idx)
          for (const part of removeParts) {
-            yield* sync.run(MessageV2.Event.PartRemoved, {
+            SyncEvent.run(MessageV2.Event.PartRemoved, {
              sessionID,
              messageID: target.info.id,
              partID: part.id,
@@ -157,7 +156,6 @@ export const defaultLayer = Layer.suspend(() =>
    Layer.provide(Storage.defaultLayer),
    Layer.provide(Bus.layer),
    Layer.provide(SessionSummary.defaultLayer),
-    Layer.provide(SyncEvent.defaultLayer),
  ),
 )

@@ -26,7 +26,7 @@ import { ProjectTable } from "../project/project.sql"
 import { Storage } from "@/storage/storage"
 import * as Log from "@opencode-ai/core/util/log"
 import { MessageV2 } from "./message-v2"
-import { Instance, type InstanceContext } from "../project/instance"
+import { Instance } from "../project/instance"
 import { InstanceState } from "@/effect/instance-state"
 import { Snapshot } from "@/snapshot"
 import { ProjectID } from "../project/schema"
@@ -142,15 +142,11 @@ const Share = Schema.Struct({
  url: Schema.String,
 })

-// Legacy HTTP accepted any number here, and persisted data may already contain
-// negative values. Keep archive timestamps permissive while other clocks stay non-negative.
-export const ArchivedTimestamp = Schema.Number
-
 const Time = Schema.Struct({
  created: NonNegativeInt,
  updated: NonNegativeInt,
  compacting: optionalOmitUndefined(NonNegativeInt),
-  archived: optionalOmitUndefined(ArchivedTimestamp),
+  archived: optionalOmitUndefined(NonNegativeInt),
 })

 const Revert = Schema.Struct({
@@ -219,7 +215,7 @@ export const SetTitleInput = Schema.Struct({ sessionID: SessionID, title: Schema
 )
 export const SetArchivedInput = Schema.Struct({
  sessionID: SessionID,
-  time: Schema.optional(ArchivedTimestamp),
+  time: Schema.optional(NonNegativeInt),
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
 export const SetPermissionInput = Schema.Struct({
  sessionID: SessionID,
@@ -248,7 +244,7 @@ const UpdatedTime = Schema.Struct({
  created: Schema.optional(Schema.NullOr(NonNegativeInt)),
  updated: Schema.optional(Schema.NullOr(NonNegativeInt)),
  compacting: Schema.optional(Schema.NullOr(NonNegativeInt)),
-  archived: Schema.optional(Schema.NullOr(ArchivedTimestamp)),
+  archived: Schema.optional(Schema.NullOr(NonNegativeInt)),
 })

 const UpdatedInfo = Schema.Struct({
@@ -311,9 +307,9 @@ export const Event = {
  ),
 }

-export function plan(input: { slug: string; time: { created: number } }, instance: InstanceContext) {
-  const base = instance.project.vcs
-    ? path.join(instance.worktree, ".opencode", "plans")
+export function plan(input: { slug: string; time: { created: number } }) {
+  const base = Instance.project.vcs
+    ? path.join(Instance.worktree, ".opencode", "plans")
    : path.join(Global.Path.data, "plans")
  return path.join(base, [input.time.created, input.slug].join("-") + ".md")
 }
@@ -443,12 +439,11 @@ export type Patch = Types.DeepMutable<SyncEvent.Event<typeof Event.Updated>["dat
 const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
  Effect.sync(() => Database.use(fn))

-export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service | SyncEvent.Service> = Layer.effect(
+export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service> = Layer.effect(
  Service,
  Effect.gen(function* () {
    const bus = yield* Bus.Service
    const storage = yield* Storage.Service
-    const sync = yield* SyncEvent.Service

    const createNext = Effect.fn("Session.createNext")(function* (input: {
      id?: SessionID
@@ -478,7 +473,7 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
      }
      log.info("created", result)

-      yield* sync.run(Event.Created, { sessionID: result.id, info: result })
+      yield* Effect.sync(() => SyncEvent.run(Event.Created, { sessionID: result.id, info: result }))

      if (!Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) {
        // This only exist for backwards compatibility. We should not be
@@ -526,8 +521,10 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
          Effect.catchCause(() => Effect.succeed(false)),
        )

-        yield* sync.run(Event.Deleted, { sessionID, info: session }, { publish: hasInstance })
-        yield* sync.remove(sessionID)
+        yield* Effect.sync(() => {
+          SyncEvent.run(Event.Deleted, { sessionID, info: session }, { publish: hasInstance })
+          SyncEvent.remove(sessionID)
+        })
      } catch (e) {
        log.error(e)
      }
@@ -535,17 +532,19 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |

    const updateMessage = <T extends MessageV2.Info>(msg: T): Effect.Effect<T> =>
      Effect.gen(function* () {
-        yield* sync.run(MessageV2.Event.Updated, { sessionID: msg.sessionID, info: msg })
+        yield* Effect.sync(() => SyncEvent.run(MessageV2.Event.Updated, { sessionID: msg.sessionID, info: msg }))
        return msg
      }).pipe(Effect.withSpan("Session.updateMessage"))

    const updatePart = <T extends MessageV2.Part>(part: T): Effect.Effect<T> =>
      Effect.gen(function* () {
-        yield* sync.run(MessageV2.Event.PartUpdated, {
-          sessionID: part.sessionID,
-          part: structuredClone(part),
-          time: Date.now(),
-        })
+        yield* Effect.sync(() =>
+          SyncEvent.run(MessageV2.Event.PartUpdated, {
+            sessionID: part.sessionID,
+            part: structuredClone(part),
+            time: Date.now(),
+          }),
+        )
        return part
      }).pipe(Effect.withSpan("Session.updatePart"))

@@ -586,7 +585,7 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
        path: sessionPath(ctx.worktree, ctx.directory),
        title: input?.title,
        permission: input?.permission,
-        workspaceID: input?.workspaceID ?? workspace,
+        workspaceID: workspace,
      })
    })

@@ -632,7 +631,8 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
      return session
    })

-    const patch = (sessionID: SessionID, info: Patch) => sync.run(Event.Updated, { sessionID, info })
+    const patch = (sessionID: SessionID, info: Patch) =>
+      Effect.sync(() => SyncEvent.run(Event.Updated, { sessionID, info }))

    const touch = Effect.fn("Session.touch")(function* (sessionID: SessionID) {
      yield* patch(sessionID, { time: { updated: Date.now() } })
@@ -689,10 +689,12 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
      sessionID: SessionID
      messageID: MessageID
    }) {
-      yield* sync.run(MessageV2.Event.Removed, {
-        sessionID: input.sessionID,
-        messageID: input.messageID,
-      })
+      yield* Effect.sync(() =>
+        SyncEvent.run(MessageV2.Event.Removed, {
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+        }),
+      )
      return input.messageID
    })

@@ -701,11 +703,13 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
      messageID: MessageID
      partID: PartID
    }) {
-      yield* sync.run(MessageV2.Event.PartRemoved, {
-        sessionID: input.sessionID,
-        messageID: input.messageID,
-        partID: input.partID,
-      })
+      yield* Effect.sync(() =>
+        SyncEvent.run(MessageV2.Event.PartRemoved, {
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+          partID: input.partID,
+        }),
+      )
      return input.partID
    })

@@ -756,11 +760,7 @@ export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service |
  }),
 )

-export const defaultLayer = layer.pipe(
-  Layer.provide(Bus.layer),
-  Layer.provide(Storage.defaultLayer),
-  Layer.provide(SyncEvent.defaultLayer),
-)
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer))

 export function* list(input?: {
  directory?: string
@@ -21,19 +21,20 @@ export const layer = Layer.effect(
    const session = yield* Session.Service
    const shareNext = yield* ShareNext.Service
    const scope = yield* Scope.Scope
-    const sync = yield* SyncEvent.Service

    const share = Effect.fn("SessionShare.share")(function* (sessionID: SessionID) {
      const conf = yield* cfg.get()
      if (conf.share === "disabled") throw new Error("Sharing is disabled in configuration")
      const result = yield* shareNext.create(sessionID)
-      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } })
+      yield* Effect.sync(() =>
+        SyncEvent.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } }),
+      )
      return result
    })

    const unshare = Effect.fn("SessionShare.unshare")(function* (sessionID: SessionID) {
      yield* shareNext.remove(sessionID)
-      yield* sync.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } })
+      yield* Effect.sync(() => SyncEvent.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } }))
    })

    const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
@@ -53,7 +54,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(ShareNext.defaultLayer),
  Layer.provide(Session.defaultLayer),
  Layer.provide(Config.defaultLayer),
-  Layer.provide(SyncEvent.defaultLayer),
 )

 export * as SessionShare from "./session"
@@ -1,3 +1,4 @@
+import os from "os"
 import path from "path"
 import { pathToFileURL } from "url"
 import z from "zod"
@@ -19,8 +20,7 @@ import * as Log from "@opencode-ai/core/util/log"
 import { Discovery } from "./discovery"

 const log = Log.create({ service: "skill" })
-const CLAUDE_EXTERNAL_DIR = ".claude"
-const AGENTS_EXTERNAL_DIR = ".agents"
+const EXTERNAL_DIRS = [".claude", ".agents"]
 const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
 const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
 const SKILL_PATTERN = "**/SKILL.md"
@@ -147,25 +147,20 @@ const discoverSkills = Effect.fnUntraced(function* (
  config: Config.Interface,
  discovery: Discovery.Interface,
  fsys: AppFileSystem.Interface,
-  global: Global.Interface,
  directory: string,
  worktree: string,
 ) {
  const state: ScanState = { matches: new Set(), dirs: new Set() }

-  const externalDirs: string[] = []
  if (!Flag.OPENCODE_DISABLE_EXTERNAL_SKILLS) {
-    if (!Flag.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS) externalDirs.push(CLAUDE_EXTERNAL_DIR)
-    externalDirs.push(AGENTS_EXTERNAL_DIR)
-
-    for (const dir of externalDirs) {
-      const root = path.join(global.home, dir)
+    for (const dir of EXTERNAL_DIRS) {
+      const root = path.join(Global.Path.home, dir)
      if (!(yield* fsys.isDir(root))) continue
      yield* scan(state, root, EXTERNAL_SKILL_PATTERN, { dot: true, scope: "global" })
    }

    const upDirs = yield* fsys
-      .up({ targets: externalDirs, start: directory, stop: worktree })
+      .up({ targets: EXTERNAL_DIRS, start: directory, stop: worktree })
      .pipe(Effect.catch(() => Effect.succeed([] as string[])))

    for (const root of upDirs) {
@@ -180,7 +175,7 @@ const discoverSkills = Effect.fnUntraced(function* (

  const cfg = yield* config.get()
  for (const item of cfg.skills?.paths ?? []) {
-    const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
+    const expanded = item.startsWith("~/") ? path.join(os.homedir(), item.slice(2)) : item
    const dir = path.isAbsolute(expanded) ? expanded : path.join(directory, expanded)
    if (!(yield* fsys.isDir(dir))) {
      log.warn("skill path not found", { path: dir })
@@ -221,14 +216,13 @@ export const layer = Layer.effect(
    const config = yield* Config.Service
    const bus = yield* Bus.Service
    const fsys = yield* AppFileSystem.Service
-    const global = yield* Global.Service
    const discovered = yield* InstanceState.make(
      Effect.fn("Skill.discovery")(function* (ctx) {
-        return yield* discoverSkills(config, discovery, fsys, global, ctx.directory, ctx.worktree)
+        return yield* discoverSkills(config, discovery, fsys, ctx.directory, ctx.worktree)
      }),
    )
    const state = yield* InstanceState.make(
-      Effect.fn("Skill.state")(function* () {
+      Effect.fn("Skill.state")(function* (ctx) {
        const s: State = { skills: {}, dirs: new Set() }
        yield* loadSkills(s, yield* InstanceState.get(discovered), bus)
        return s
@@ -265,7 +259,6 @@ export const defaultLayer = layer.pipe(
  Layer.provide(Config.defaultLayer),
  Layer.provide(Bus.layer),
  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Global.layer),
 )

 export function fmt(list: Info[], opts: { verbose: boolean }) {
@@ -9,11 +9,9 @@ import { EventSequenceTable, EventTable } from "./event.sql"
 import { WorkspaceContext } from "@/control-plane/workspace-context"
 import { EventID } from "./schema"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { Context, Effect, Layer, Schema as EffectSchema } from "effect"
+import { Schema as EffectSchema } from "effect"
 import { zodObject } from "@/util/effect-zod"
 import type { DeepMutable } from "@/util/schema"
-import { makeRuntime } from "@/effect/run-service"
-import { serviceUse } from "@/effect/service-use"

 // Keep `Event["data"]` mutable because projectors mutate the persisted shape
 // when writing to the database. Bus payloads (`Properties`) stay readonly —
@@ -48,125 +46,6 @@ export type SerializedEvent<Def extends Definition = Definition> = Event<Def> &
 type ProjectorFunc = (db: Database.TxOrDb, data: unknown) => void
 type ConvertEvent = (type: string, data: Event["data"]) => unknown | Promise<unknown>

-export interface Interface {
-  readonly run: <Def extends Definition>(
-    def: Def,
-    data: Event<Def>["data"],
-    options?: { publish?: boolean },
-  ) => Effect.Effect<void>
-  readonly replay: (event: SerializedEvent, options?: { publish: boolean }) => Effect.Effect<void>
-  readonly replayAll: (events: SerializedEvent[], options?: { publish: boolean }) => Effect.Effect<string | undefined>
-  readonly remove: (aggregateID: string) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SyncEvent") {}
-
-export const layer = Layer.effect(Service)(
-  Effect.gen(function* () {
-    const replay: Interface["replay"] = Effect.fn("SyncEvent.replay")(function* (event, options) {
-      const def = registry.get(event.type)
-      if (!def) {
-        throw new Error(`Unknown event type: ${event.type}`)
-      }
-
-      const row = Database.use((db) =>
-        db
-          .select({ seq: EventSequenceTable.seq })
-          .from(EventSequenceTable)
-          .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
-          .get(),
-      )
-
-      const latest = row?.seq ?? -1
-      if (event.seq <= latest) return
-
-      const expected = latest + 1
-      if (event.seq !== expected) {
-        throw new Error(
-          `Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`,
-        )
-      }
-
-      process(def, event, { publish: !!options?.publish })
-    })
-
-    const replayAll: Interface["replayAll"] = Effect.fn("SyncEvent.replayAll")(function* (events, options) {
-      const source = events[0]?.aggregateID
-      if (!source) return undefined
-      if (events.some((item) => item.aggregateID !== source)) {
-        throw new Error("Replay events must belong to the same session")
-      }
-      const start = events[0].seq
-      for (const [i, item] of events.entries()) {
-        const seq = start + i
-        if (item.seq !== seq) {
-          throw new Error(`Replay sequence mismatch at index ${i}: expected ${seq}, got ${item.seq}`)
-        }
-      }
-      for (const item of events) {
-        yield* replay(item, options)
-      }
-      return source
-    })
-
-    const run: Interface["run"] = Effect.fn("SyncEvent.run")(function* (def, data, options) {
-      const agg = (data as Record<string, string>)[def.aggregate]
-      // This should never happen: we've enforced it via typescript in
-      // the definition
-      if (agg == null) {
-        throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
-      }
-
-      if (def.version !== versions.get(def.type)) {
-        throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
-      }
-
-      const { publish = true } = options || {}
-
-      // Note that this is an "immediate" transaction which is critical.
-      // We need to make sure we can safely read and write with nothing
-      // else changing the data from under us
-      Database.transaction(
-        (tx) => {
-          const id = EventID.ascending()
-          const row = tx
-            .select({ seq: EventSequenceTable.seq })
-            .from(EventSequenceTable)
-            .where(eq(EventSequenceTable.aggregate_id, agg))
-            .get()
-          const seq = row?.seq != null ? row.seq + 1 : 0
-
-          const event = { id, seq, aggregateID: agg, data }
-          process(def, event, { publish })
-        },
-        {
-          behavior: "immediate",
-        },
-      )
-    })
-
-    const remove: Interface["remove"] = Effect.fn("SyncEvent.remove")(function* (aggregateID) {
-      Database.transaction((tx) => {
-        tx.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
-        tx.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
-      })
-    })
-
-    return Service.of({
-      run,
-      replay,
-      replayAll,
-      remove,
-    })
-  }),
-)
-
-export const defaultLayer = layer
-
-export const use = serviceUse(Service)
-
-const runtime = makeRuntime(Service, defaultLayer)
-
 export const registry = new Map<string, Definition>()
 let projectors: Map<Definition, ProjectorFunc> | undefined
 const versions = new Map<string, number>()
@@ -307,19 +186,92 @@ function process<Def extends Definition>(def: Def, event: Event<Def>, options: {
 }

 export function replay(event: SerializedEvent, options?: { publish: boolean }) {
-  return runtime.runSync((sync) => sync.replay(event, options))
+  const def = registry.get(event.type)
+  if (!def) {
+    throw new Error(`Unknown event type: ${event.type}`)
+  }
+
+  const row = Database.use((db) =>
+    db
+      .select({ seq: EventSequenceTable.seq })
+      .from(EventSequenceTable)
+      .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
+      .get(),
+  )
+
+  const latest = row?.seq ?? -1
+  if (event.seq <= latest) {
+    return
+  }
+
+  const expected = latest + 1
+  if (event.seq !== expected) {
+    throw new Error(`Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`)
+  }
+
+  process(def, event, { publish: !!options?.publish })
 }

 export function replayAll(events: SerializedEvent[], options?: { publish: boolean }) {
-  return runtime.runSync((sync) => sync.replayAll(events, options))
+  const source = events[0]?.aggregateID
+  if (!source) return
+  if (events.some((item) => item.aggregateID !== source)) {
+    throw new Error("Replay events must belong to the same session")
+  }
+  const start = events[0].seq
+  for (const [i, item] of events.entries()) {
+    const seq = start + i
+    if (item.seq !== seq) {
+      throw new Error(`Replay sequence mismatch at index ${i}: expected ${seq}, got ${item.seq}`)
+    }
+  }
+  for (const item of events) {
+    replay(item, options)
+  }
+  return source
 }

 export function run<Def extends Definition>(def: Def, data: Event<Def>["data"], options?: { publish?: boolean }) {
-  return runtime.runSync((sync) => sync.run(def, data, options))
+  const agg = (data as Record<string, string>)[def.aggregate]
+  // This should never happen: we've enforced it via typescript in
+  // the definition
+  if (agg == null) {
+    throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
+  }
+
+  if (def.version !== versions.get(def.type)) {
+    throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
+  }
+
+  const { publish = true } = options || {}
+
+  // Note that this is an "immediate" transaction which is critical.
+  // We need to make sure we can safely read and write with nothing
+  // else changing the data from under us
+  Database.transaction(
+    (tx) => {
+      const id = EventID.ascending()
+      const row = tx
+        .select({ seq: EventSequenceTable.seq })
+        .from(EventSequenceTable)
+        .where(eq(EventSequenceTable.aggregate_id, agg))
+        .get()
+      const seq = row?.seq != null ? row.seq + 1 : 0
+
+      const event = { id, seq, aggregateID: agg, data }
+      process(def, event, { publish })
+    },
+    {
+      behavior: "immediate",
+    },
+  )
 }

 export function remove(aggregateID: string) {
-  return runtime.runSync((sync) => sync.remove(aggregateID))
+  Database.transaction((tx) => {
+    tx.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
+    tx.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
+  })
 }

 export function payloads() {
@@ -3,7 +3,7 @@ import { Effect, Schema } from "effect"
 import * as Tool from "./tool"
 import { Bus } from "../bus"
 import { FileWatcher } from "../file/watcher"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { Patch } from "../patch"
 import { createTwoFilesPatch, diffLines } from "diff"
 import { assertExternalDirectoryEffect } from "./external-directory"
@@ -52,8 +52,6 @@ export const ApplyPatchTool = Tool.define(
        return yield* Effect.fail(new Error("apply_patch verification failed: no hunks found"))
      }

-      const instance = yield* InstanceState.context
-
      // Validate file paths and check permissions
      const fileChanges: Array<{
        filePath: string
@@ -70,7 +68,7 @@ export const ApplyPatchTool = Tool.define(
      let totalDiff = ""

      for (const hunk of hunks) {
-        const filePath = path.resolve(instance.directory, hunk.path)
+        const filePath = path.resolve(Instance.directory, hunk.path)
        yield* assertExternalDirectoryEffect(ctx, filePath)

        switch (hunk.type) {
@@ -135,7 +133,7 @@ export const ApplyPatchTool = Tool.define(
              if (change.removed) deletions += change.count || 0
            }

-            const movePath = hunk.move_path ? path.resolve(instance.directory, hunk.move_path) : undefined
+            const movePath = hunk.move_path ? path.resolve(Instance.directory, hunk.move_path) : undefined
            yield* assertExternalDirectoryEffect(ctx, movePath)

            fileChanges.push({
@@ -189,7 +187,7 @@ export const ApplyPatchTool = Tool.define(
      // Build per-file metadata for UI rendering (used for both permission and result)
      const files = fileChanges.map((change) => ({
        filePath: change.filePath,
-        relativePath: path.relative(instance.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
+        relativePath: path.relative(Instance.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
        type: change.type,
        patch: change.diff,
        additions: change.additions,
@@ -198,7 +196,7 @@ export const ApplyPatchTool = Tool.define(
      }))

      // Check permissions if needed
-      const relativePaths = fileChanges.map((c) => path.relative(instance.worktree, c.filePath).replaceAll("\\", "/"))
+      const relativePaths = fileChanges.map((c) => path.relative(Instance.worktree, c.filePath).replaceAll("\\", "/"))
      yield* ctx.ask({
        permission: "edit",
        patterns: relativePaths,
@@ -269,13 +267,13 @@ export const ApplyPatchTool = Tool.define(
      // Generate output summary
      const summaryLines = fileChanges.map((change) => {
        if (change.type === "add") {
-          return `A ${path.relative(instance.worktree, change.filePath).replaceAll("\\", "/")}`
+          return `A ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
        }
        if (change.type === "delete") {
-          return `D ${path.relative(instance.worktree, change.filePath).replaceAll("\\", "/")}`
+          return `D ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
        }
        const target = change.movePath ?? change.filePath
-        return `M ${path.relative(instance.worktree, target).replaceAll("\\", "/")}`
+        return `M ${path.relative(Instance.worktree, target).replaceAll("\\", "/")}`
      })
      let output = `Success. Updated the following files:\n${summaryLines.join("\n")}`

@@ -284,7 +282,7 @@ export const ApplyPatchTool = Tool.define(
        const target = change.movePath ?? change.filePath
        const block = LSP.Diagnostic.report(target, diagnostics[AppFileSystem.normalizePath(target)] ?? [])
        if (!block) continue
-        const rel = path.relative(instance.worktree, target).replaceAll("\\", "/")
+        const rel = path.relative(Instance.worktree, target).replaceAll("\\", "/")
        output += `\n\nLSP errors detected in ${rel}, please fix:\n${block}`
      }

@@ -6,7 +6,7 @@ import * as Tool from "./tool"
 import path from "path"
 import DESCRIPTION from "./bash.txt"
 import * as Log from "@opencode-ai/core/util/log"
-import { Instance, type InstanceContext } from "../project/instance"
+import { Instance } from "../project/instance"
 import { lazy } from "@/util/lazy"
 import { Language, type Node } from "web-tree-sitter"

@@ -363,13 +363,7 @@ export const BashTool = Tool.define(
      return yield* resolvePath(next, cwd, shell)
    })

-    const collect = Effect.fn("BashTool.collect")(function* (
-      root: Node,
-      cwd: string,
-      ps: boolean,
-      shell: string,
-      instance: InstanceContext,
-    ) {
+    const collect = Effect.fn("BashTool.collect")(function* (root: Node, cwd: string, ps: boolean, shell: string) {
      const scan: Scan = {
        dirs: new Set<string>(),
        patterns: new Set<string>(),
@@ -385,7 +379,7 @@ export const BashTool = Tool.define(
          for (const arg of pathArgs(command, ps)) {
            const resolved = yield* argPath(arg, cwd, ps, shell)
            log.info("resolved path", { arg, resolved })
-            if (!resolved || Instance.containsPath(resolved, instance)) continue
+            if (!resolved || Instance.containsPath(resolved)) continue
            const dir = (yield* fs.isDir(resolved)) ? resolved : path.dirname(resolved)
            scan.dirs.add(dir)
          }
@@ -595,10 +589,9 @@ export const BashTool = Tool.define(
          parameters: Parameters,
          execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
            Effect.gen(function* () {
-              const executeInstance = yield* InstanceState.context
              const cwd = params.workdir
-                ? yield* resolvePath(params.workdir, executeInstance.directory, shell)
-                : executeInstance.directory
+                ? yield* resolvePath(params.workdir, Instance.directory, shell)
+                : Instance.directory
              if (params.timeout !== undefined && params.timeout < 0) {
                throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
              }
@@ -609,8 +602,8 @@ export const BashTool = Tool.define(
                  const tree = yield* Effect.acquireRelease(parse(params.command, ps), (tree) =>
                    Effect.sync(() => tree.delete()),
                  )
-                  const scan = yield* collect(tree.rootNode, cwd, ps, shell, executeInstance)
-                  if (!Instance.containsPath(cwd, executeInstance)) scan.dirs.add(cwd)
+                  const scan = yield* collect(tree.rootNode, cwd, ps, shell)
+                  if (!Instance.containsPath(cwd)) scan.dirs.add(cwd)
                  yield* ask(ctx, scan)
                }),
              )
@@ -13,7 +13,7 @@ import { File } from "../file"
 import { FileWatcher } from "../file/watcher"
 import { Bus } from "../bus"
 import { Format } from "../format"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { Snapshot } from "@/snapshot"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
@@ -76,10 +76,9 @@ export const EditTool = Tool.define(
            throw new Error("No changes to apply: oldString and newString are identical.")
          }

-          const instance = yield* InstanceState.context
          const filePath = path.isAbsolute(params.filePath)
            ? params.filePath
-            : path.join(instance.directory, params.filePath)
+            : path.join(Instance.directory, params.filePath)
          yield* assertExternalDirectoryEffect(ctx, filePath)

          let diff = ""
@@ -97,7 +96,7 @@ export const EditTool = Tool.define(
                diff = trimDiff(createTwoFilesPatch(filePath, filePath, contentOld, contentNew))
                yield* ctx.ask({
                  permission: "edit",
-                  patterns: [path.relative(instance.worktree, filePath)],
+                  patterns: [path.relative(Instance.worktree, filePath)],
                  always: ["*"],
                  metadata: {
                    filepath: filePath,
@@ -140,7 +139,7 @@ export const EditTool = Tool.define(
              )
              yield* ctx.ask({
                permission: "edit",
-                patterns: [path.relative(instance.worktree, filePath)],
+                patterns: [path.relative(Instance.worktree, filePath)],
                always: ["*"],
                metadata: {
                  filepath: filePath,
@@ -202,7 +201,7 @@ export const EditTool = Tool.define(
              diff,
              filediff,
            },
-            title: `${path.relative(instance.worktree, filePath)}`,
+            title: `${path.relative(Instance.worktree, filePath)}`,
            output,
          }
        }),
@@ -3,7 +3,7 @@ import * as Tool from "./tool"
 import path from "path"
 import { LSP } from "@/lsp/lsp"
 import DESCRIPTION from "./lsp.txt"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { pathToFileURL } from "url"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
@@ -44,8 +44,7 @@ export const LspTool = Tool.define(
      parameters: Parameters,
      execute: (args: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
-          const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(instance.directory, args.filePath)
+          const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(Instance.directory, args.filePath)
          yield* assertExternalDirectoryEffect(ctx, file)
          const meta =
            args.operation === "workspaceSymbol"
@@ -62,7 +61,7 @@ export const LspTool = Tool.define(

          const uri = pathToFileURL(file).href
          const position = { file, line: args.line - 1, character: args.character - 1 }
-          const relPath = path.relative(instance.worktree, file)
+          const relPath = path.relative(Instance.worktree, file)
          const detail =
            args.operation === "workspaceSymbol"
              ? ""
@@ -5,7 +5,7 @@ import { Question } from "../question"
 import { Session } from "@/session/session"
 import { MessageV2 } from "../session/message-v2"
 import { Provider } from "@/provider/provider"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { type SessionID, MessageID, PartID } from "../session/schema"
 import EXIT_DESCRIPTION from "./plan-exit.txt"

@@ -30,9 +30,8 @@ export const PlanExitTool = Tool.define(
      parameters: Parameters,
      execute: (_params: {}, ctx: Tool.Context) =>
        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
          const info = yield* session.get(ctx.sessionID)
-          const plan = path.relative(instance.worktree, Session.plan(info, instance))
+          const plan = path.relative(Instance.worktree, Session.plan(info))
          const answers = yield* question.ask({
            sessionID: ctx.sessionID,
            questions: [
@@ -7,7 +7,7 @@ import * as Tool from "./tool"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
 import { LSP } from "@/lsp/lsp"
 import DESCRIPTION from "./read.txt"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import { Instruction } from "../session/instruction"
 import { isImageAttachment, isPdfAttachment, sniffAttachmentMime } from "@/util/media"
@@ -157,15 +157,14 @@ export const ReadTool = Tool.define(
        return yield* Effect.fail(new Error("offset must be greater than or equal to 1"))
      }

-      const instance = yield* InstanceState.context
      let filepath = params.filePath
      if (!path.isAbsolute(filepath)) {
-        filepath = path.resolve(instance.directory, filepath)
+        filepath = path.resolve(Instance.directory, filepath)
      }
      if (process.platform === "win32") {
        filepath = AppFileSystem.normalizePath(filepath)
      }
-      const title = path.relative(instance.worktree, filepath)
+      const title = path.relative(Instance.worktree, filepath)

      const stat = yield* fs.stat(filepath).pipe(
        Effect.catchIf(
@@ -64,16 +64,12 @@ export const TaskTool = Tool.define(
      const session = taskID
        ? yield* sessions.get(SessionID.make(taskID)).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
        : undefined
-      const parent = yield* sessions.get(ctx.sessionID)
      const nextSession =
        session ??
        (yield* sessions.create({
          parentID: ctx.sessionID,
          title: params.description + ` (@${next.name} subagent)`,
          permission: [
-            ...(parent.permission ?? []).filter(
-              (rule) => rule.permission === "external_directory" || rule.action === "deny",
-            ),
            ...(canTodo
              ? []
              : [
@@ -10,7 +10,7 @@ import { File } from "../file"
 import { FileWatcher } from "../file/watcher"
 import { Format } from "../format"
 import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { InstanceState } from "@/effect/instance-state"
+import { Instance } from "../project/instance"
 import { trimDiff } from "./edit"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import * as Bom from "@/util/bom"
@@ -37,10 +37,9 @@ export const WriteTool = Tool.define(
      parameters: Parameters,
      execute: (params: { content: string; filePath: string }, ctx: Tool.Context) =>
        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
          const filepath = path.isAbsolute(params.filePath)
            ? params.filePath
-            : path.join(instance.directory, params.filePath)
+            : path.join(Instance.directory, params.filePath)
          yield* assertExternalDirectoryEffect(ctx, filepath)

          const exists = yield* fs.existsSafe(filepath)
@@ -53,7 +52,7 @@ export const WriteTool = Tool.define(
          const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, contentNew))
          yield* ctx.ask({
            permission: "edit",
-            patterns: [path.relative(instance.worktree, filepath)],
+            patterns: [path.relative(Instance.worktree, filepath)],
            always: ["*"],
            metadata: {
              filepath,
@@ -90,7 +89,7 @@ export const WriteTool = Tool.define(
          }

          return {
-            title: path.relative(instance.worktree, filepath),
+            title: path.relative(Instance.worktree, filepath),
            metadata: {
              diagnostics,
              filepath,
@@ -10,7 +10,6 @@ type ZedFixtureOptions = {
  editor?: boolean
  selectionStart?: number | null
  selectionEnd?: number | null
-  selections?: Array<{ start: number | null; end: number | null }>
  contents?: string
 }

@@ -31,16 +30,10 @@ async function writeZedFixture(dir: string, options: ZedFixtureOptions = {}) {
  db.run("insert into items values (1, 1, 1, 1, ?)", [options.itemKind ?? "Editor"])
  if (options.editor !== false) {
    db.run("insert into editors values (1, 1, ?, ?)", [filePath, contents])
-    ;(
-      options.selections ?? [
-        {
-          start: options.selectionStart === undefined ? 4 : options.selectionStart,
-          end: options.selectionEnd === undefined ? 7 : options.selectionEnd,
-        },
-      ]
-    ).forEach((selection) =>
-      db.run("insert into editor_selections values (1, 1, ?, ?)", [selection.start, selection.end]),
-    )
+    db.run("insert into editor_selections values (1, 1, ?, ?)", [
+      options.selectionStart === undefined ? 4 : options.selectionStart,
+      options.selectionEnd === undefined ? 7 : options.selectionEnd,
+    ])
  }
  db.close()

@@ -73,59 +66,13 @@ test("resolveZedSelection returns active editor selection", async () => {
  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
    type: "selection",
    selection: {
+      text: "two",
      filePath: fixture.filePath,
      source: "zed",
-      ranges: [
-        {
-          text: "two",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 4 },
-          },
-        },
-      ],
-    },
-  })
-})
-
-test("resolveZedSelection returns all active editor selections sorted by offset", async () => {
-  await using tmp = await tmpdir()
-  const contents = "one\ntwo\nthree\nfour"
-  const fixture = await writeZedFixture(tmp.path, {
-    contents,
-    selections: [
-      {
-        start: utf8ByteOffset(contents, contents.indexOf("four")),
-        end: utf8ByteOffset(contents, contents.indexOf("four") + 4),
+      selection: {
+        start: { line: 2, character: 1 },
+        end: { line: 2, character: 4 },
      },
-      {
-        start: utf8ByteOffset(contents, contents.indexOf("two")),
-        end: utf8ByteOffset(contents, contents.indexOf("two") + 3),
-      },
-    ],
-  })
-
-  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
-    type: "selection",
-    selection: {
-      filePath: fixture.filePath,
-      source: "zed",
-      ranges: [
-        {
-          text: "two",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 4 },
-          },
-        },
-        {
-          text: "four",
-          selection: {
-            start: { line: 4, character: 1 },
-            end: { line: 4, character: 5 },
-          },
-        },
-      ],
    },
  })
 })
@@ -143,17 +90,13 @@ test("resolveZedSelection converts Zed UTF-8 byte offsets to string offsets", as
  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
    type: "selection",
    selection: {
+      text: "TARGET",
      filePath: fixture.filePath,
      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 4, character: 1 },
-            end: { line: 4, character: 7 },
-          },
-        },
-      ],
+      selection: {
+        start: { line: 4, character: 1 },
+        end: { line: 4, character: 7 },
+      },
    },
  })
 })
@@ -171,17 +114,13 @@ test("resolveZedSelection handles non-ASCII text inside the selected range", asy
  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
    type: "selection",
    selection: {
+      text: "выбор",
      filePath: fixture.filePath,
      source: "zed",
-      ranges: [
-        {
-          text: "выбор",
-          selection: {
-            start: { line: 3, character: 1 },
-            end: { line: 3, character: 6 },
-          },
-        },
-      ],
+      selection: {
+        start: { line: 3, character: 1 },
+        end: { line: 3, character: 6 },
+      },
    },
  })
 })
@@ -199,17 +138,13 @@ test("resolveZedSelection handles emoji before the selected range", async () =>
  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
    type: "selection",
    selection: {
+      text: "TARGET",
      filePath: fixture.filePath,
      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 2, character: 1 },
-            end: { line: 2, character: 7 },
-          },
-        },
-      ],
+      selection: {
+        start: { line: 2, character: 1 },
+        end: { line: 2, character: 7 },
+      },
    },
  })
 })
@@ -227,17 +162,13 @@ test("resolveZedSelection handles reversed Zed byte offsets", async () => {
  expect(await resolveZedSelection(fixture.dbPath, tmp.path)).toEqual({
    type: "selection",
    selection: {
+      text: "TARGET",
      filePath: fixture.filePath,
      source: "zed",
-      ranges: [
-        {
-          text: "TARGET",
-          selection: {
-            start: { line: 3, character: 1 },
-            end: { line: 3, character: 7 },
-          },
-        },
-      ],
+      selection: {
+        start: { line: 3, character: 1 },
+        end: { line: 3, character: 7 },
+      },
    },
  })
 })
@@ -190,17 +190,13 @@ test("useEditorContext resets selection when reconnecting", async () => {
    serverInfo: { name: "test", version: "0.0.0" },
  })
  expect(mounted.editor.selection()).toEqual({
+    text: "foo",
    filePath: path.join(startupDirectory, "file.ts"),
    source: "websocket",
-    ranges: [
-      {
-        text: "foo",
-        selection: {
-          start: { line: 1, character: 1 },
-          end: { line: 1, character: 4 },
-        },
-      },
-    ],
+    selection: {
+      start: { line: 1, character: 1 },
+      end: { line: 1, character: 4 },
+    },
  })

  mounted.editor.reconnect(startupDirectory)
@@ -1,28 +1,120 @@
-import { describe, expect, test } from "bun:test"
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { tmpdir } from "../../fixture/fixture"
-import { resolveThreadDirectory } from "../../../src/cli/cmd/tui/thread"
+import * as App from "../../../src/cli/cmd/tui/app"
+import { Rpc } from "@/util/rpc"
+import { UI } from "../../../src/cli/ui"
+import * as Timeout from "../../../src/util/timeout"
+import * as Network from "../../../src/cli/network"
+import * as Win32 from "../../../src/cli/cmd/tui/win32"
+import { TuiConfig } from "../../../src/cli/cmd/tui/config/tui"
+
+const stop = new Error("stop")
+const seen = {
+  tui: [] as string[],
+}
+
+function setup() {
+  // Intentionally avoid mock.module() here: Bun keeps module overrides in cache
+  // and mock.restore() does not reset mock.module values. If this switches back
+  // to module mocks, later suites can see mocked @/config/tui and fail (e.g.
+  // plugin-loader tests expecting real TuiConfig.waitForDependencies). See:
+  // https://github.com/oven-sh/bun/issues/7823 and #12823.
+  spyOn(App, "tui").mockImplementation(async (input) => {
+    if (input.directory) seen.tui.push(input.directory)
+    throw stop
+  })
+  spyOn(Rpc, "client").mockImplementation(() => ({
+    call: async () => ({ url: "http://127.0.0.1" }) as never,
+    on: () => () => {},
+  }))
+  spyOn(UI, "error").mockImplementation(() => {})
+  spyOn(Timeout, "withTimeout").mockImplementation((input) => input)
+  spyOn(Network, "resolveNetworkOptions").mockResolvedValue({
+    mdns: false,
+    port: 0,
+    hostname: "127.0.0.1",
+    mdnsDomain: "opencode.local",
+    cors: [],
+  })
+  spyOn(Win32, "win32DisableProcessedInput").mockImplementation(() => {})
+  spyOn(Win32, "win32InstallCtrlCGuard").mockReturnValue(undefined)
+}

 describe("tui thread", () => {
+  afterEach(() => {
+    mock.restore()
+  })
+
+  async function call(project?: string) {
+    const { TuiThreadCommand } = await import("../../../src/cli/cmd/tui/thread")
+    const args: Parameters<NonNullable<typeof TuiThreadCommand.handler>>[0] = {
+      _: [],
+      $0: "opencode",
+      project,
+      prompt: "hi",
+      model: undefined,
+      agent: undefined,
+      session: undefined,
+      continue: false,
+      fork: false,
+      port: 0,
+      hostname: "127.0.0.1",
+      mdns: false,
+      "mdns-domain": "opencode.local",
+      mdnsDomain: "opencode.local",
+      cors: [],
+    }
+    return TuiThreadCommand.handler(args)
+  }
+
  async function check(project?: string) {
+    setup()
+    const cwd = process.cwd()
+    const pwd = process.env.PWD
+    const worker = globalThis.Worker
+    const tty = Object.getOwnPropertyDescriptor(process.stdin, "isTTY")
    await using tmp = await tmpdir({ git: true })
    const link = path.join(path.dirname(tmp.path), path.basename(tmp.path) + "-link")
    const type = process.platform === "win32" ? "junction" : "dir"
+    seen.tui.length = 0
+    await fs.symlink(tmp.path, link, type)
+
+    Object.defineProperty(process.stdin, "isTTY", {
+      configurable: true,
+      value: true,
+    })
+    globalThis.Worker = class extends EventTarget {
+      onerror = null
+      onmessage = null
+      onmessageerror = null
+      postMessage() {}
+      terminate() {}
+    } as unknown as typeof Worker

    try {
-      await fs.symlink(tmp.path, link, type)
-      expect(resolveThreadDirectory(project, link, tmp.path)).toBe(tmp.path)
+      process.chdir(tmp.path)
+      process.env.PWD = link
+      await expect(call(project)).rejects.toBe(stop)
+      expect(seen.tui[0]).toBe(tmp.path)
    } finally {
+      process.chdir(cwd)
+      if (pwd === undefined) delete process.env.PWD
+      else process.env.PWD = pwd
+      if (tty) Object.defineProperty(process.stdin, "isTTY", tty)
+      else delete (process.stdin as { isTTY?: boolean }).isTTY
+      globalThis.Worker = worker
      await fs.rm(link, { recursive: true, force: true }).catch(() => undefined)
    }
  }

-  test("uses the real cwd when PWD points at a symlink", async () => {
+  // serial because both modify real env vars
+  test.serial("uses the real cwd when PWD points at a symlink", async () => {
    await check()
  })

-  test("uses the real cwd after resolving a relative project from PWD", async () => {
+  test.serial("uses the real cwd after resolving a relative project from PWD", async () => {
    await check(".")
  })
 })
@@ -1,59 +1,67 @@
 import { test, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { Effect } from "effect"
 import path from "path"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
+import { provideInstance, tmpdir } from "../fixture/fixture"
+import { Instance } from "../../src/project/instance"
 import { Config } from "@/config/config"
 import { Agent as AgentSvc } from "../../src/agent/agent"
 import { Color } from "@/util/color"
 import { AppRuntime } from "../../src/effect/app-runtime"
-import { testEffect } from "../lib/effect"

-const it = testEffect(Layer.mergeAll(AgentSvc.defaultLayer, CrossSpawnSpawner.defaultLayer))
+const load = () => AppRuntime.runPromise(Config.Service.use((svc) => svc.get()))
+const agent = <A>(dir: string, fn: (svc: AgentSvc.Interface) => Effect.Effect<A>) =>
+  Effect.runPromise(provideInstance(dir)(AgentSvc.Service.use(fn)).pipe(Effect.provide(AgentSvc.defaultLayer)))

-const writeConfig = (dir: string, agent: Config.Info["agent"]) =>
-  Effect.promise(() =>
-    Bun.write(
-      path.join(dir, "opencode.json"),
-      JSON.stringify({
-        $schema: "https://opencode.ai/config.json",
-        agent,
-      }),
-    ),
-  )
-
-it.live("agent color parsed from project config", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    yield* writeConfig(dir, {
-      build: { color: "#FFA500" },
-      plan: { color: "primary" },
-    })
-
-    yield* Effect.gen(function* () {
-      const cfg = yield* Effect.promise(() => AppRuntime.runPromise(Config.Service.use((svc) => svc.get())))
+test("agent color parsed from project config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          agent: {
+            build: { color: "#FFA500" },
+            plan: { color: "primary" },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const cfg = await load()
      expect(cfg.agent?.["build"]?.color).toBe("#FFA500")
      expect(cfg.agent?.["plan"]?.color).toBe("primary")
-    }).pipe(provideInstance(dir))
-  }),
-)
+    },
+  })
+})

-it.live("Agent.get includes color from config", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    yield* writeConfig(dir, {
-      plan: { color: "#A855F7" },
-      build: { color: "accent" },
-    })
-
-    yield* Effect.gen(function* () {
-      const plan = yield* AgentSvc.Service.use((svc) => svc.get("plan"))
+test("Agent.get includes color from config", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          agent: {
+            plan: { color: "#A855F7" },
+            build: { color: "accent" },
+          },
+        }),
+      )
+    },
+  })
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const plan = await agent(tmp.path, (svc) => svc.get("plan"))
      expect(plan?.color).toBe("#A855F7")
-      const build = yield* AgentSvc.Service.use((svc) => svc.get("build"))
+      const build = await agent(tmp.path, (svc) => svc.get("build"))
      expect(build?.color).toBe("accent")
-    }).pipe(provideInstance(dir))
-  }),
-)
+    },
+  })
+})

 test("Color.hexToAnsiBold converts valid hex to ANSI", () => {
  const result = Color.hexToAnsiBold("#FFA500")
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { getAdaptor, registerAdaptor } from "../../src/control-plane/adaptors"
+import { getAdapter, registerAdapter } from "../../src/control-plane/adapters"
 import { ProjectID } from "../../src/project/schema"
 import type { WorkspaceInfo } from "../../src/control-plane/types"

@@ -15,7 +15,7 @@ function info(projectID: WorkspaceInfo["projectID"], type: string): WorkspaceInf
  }
 }

-function adaptor(dir: string) {
+function adapter(dir: string) {
  return {
    name: dir,
    description: dir,
@@ -33,19 +33,19 @@ function adaptor(dir: string) {
  }
 }

-describe("control-plane/adaptors", () => {
-  test("isolates custom adaptors by project", async () => {
+describe("control-plane/adapters", () => {
+  test("isolates custom adapters by project", async () => {
    const type = `demo-${Math.random().toString(36).slice(2)}`
    const one = ProjectID.make(`project-${Math.random().toString(36).slice(2)}`)
    const two = ProjectID.make(`project-${Math.random().toString(36).slice(2)}`)
-    registerAdaptor(one, type, adaptor("/one"))
-    registerAdaptor(two, type, adaptor("/two"))
+    registerAdapter(one, type, adapter("/one"))
+    registerAdapter(two, type, adapter("/two"))

-    expect(await (await getAdaptor(one, type)).target(info(one, type))).toEqual({
+    expect(await (await getAdapter(one, type)).target(info(one, type))).toEqual({
      type: "local",
      directory: "/one",
    })
-    expect(await (await getAdaptor(two, type)).target(info(two, type))).toEqual({
+    expect(await (await getAdapter(two, type)).target(info(two, type))).toEqual({
      type: "local",
      directory: "/two",
    })
@@ -54,16 +54,16 @@ describe("control-plane/adaptors", () => {
  test("latest install wins within a project", async () => {
    const type = `demo-${Math.random().toString(36).slice(2)}`
    const id = ProjectID.make(`project-${Math.random().toString(36).slice(2)}`)
-    registerAdaptor(id, type, adaptor("/one"))
+    registerAdapter(id, type, adapter("/one"))

-    expect(await (await getAdaptor(id, type)).target(info(id, type))).toEqual({
+    expect(await (await getAdapter(id, type)).target(info(id, type))).toEqual({
      type: "local",
      directory: "/one",
    })

-    registerAdaptor(id, type, adaptor("/two"))
+    registerAdapter(id, type, adapter("/two"))

-    expect(await (await getAdaptor(id, type)).target(info(id, type))).toEqual({
+    expect(await (await getAdapter(id, type)).target(info(id, type))).toEqual({
      type: "local",
      directory: "/two",
    })
@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { parseSSE } from "../../src/control-plane/sse"
+import { resetDatabase } from "../fixture/db"
+
+afterEach(async () => {
+  await resetDatabase()
+})
+
+function stream(chunks: string[]) {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      const encoder = new TextEncoder()
+      chunks.forEach((chunk) => controller.enqueue(encoder.encode(chunk)))
+      controller.close()
+    },
+  })
+}
+
+describe("control-plane/sse", () => {
+  test("parses JSON events with CRLF and multiline data blocks", async () => {
+    const events: unknown[] = []
+    const stop = new AbortController()
+
+    await parseSSE(
+      stream([
+        'data: {"type":"one","properties":{"ok":true}}\r\n\r\n',
+        'data: {"type":"two",\r\ndata: "properties":{"n":2}}\r\n\r\n',
+      ]),
+      stop.signal,
+      (event) => events.push(event),
+    )
+
+    expect(events).toEqual([
+      { type: "one", properties: { ok: true } },
+      { type: "two", properties: { n: 2 } },
+    ])
+  })
+
+  test("falls back to sse.message for non-json payload", async () => {
+    const events: unknown[] = []
+    const stop = new AbortController()
+
+    await parseSSE(stream(["id: abc\nretry: 1500\ndata: hello world\n\n"]), stop.signal, (event) => events.push(event))
+
+    expect(events).toEqual([
+      {
+        type: "sse.message",
+        properties: {
+          data: "hello world",
+          id: "abc",
+          retry: 1500,
+        },
+      },
+    ])
+  })
+})
@@ -1,15 +1,12 @@
-import { expect } from "bun:test"
+import { expect, test } from "bun:test"
 import { Context, Effect, Layer, Logger } from "effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
 import { AppRuntime } from "../../src/effect/app-runtime"
 import { EffectBridge } from "@/effect/bridge"
 import { InstanceRef } from "../../src/effect/instance-ref"
 import * as EffectLogger from "@opencode-ai/core/effect/logger"
 import { makeRuntime } from "../../src/effect/run-service"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(CrossSpawnSpawner.defaultLayer)
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"

 function check(loggers: ReadonlySet<Logger.Logger<unknown, any>>) {
  return {
@@ -20,58 +17,56 @@ function check(loggers: ReadonlySet<Logger.Logger<unknown, any>>) {
  }
 }

-it.live("makeRuntime installs EffectLogger through Observability.layer", () =>
-  Effect.gen(function* () {
-    class Dummy extends Context.Service<Dummy, { readonly current: () => Effect.Effect<ReturnType<typeof check>> }>()(
-      "@test/Dummy",
-    ) {}
+test("makeRuntime installs EffectLogger through Observability.layer", async () => {
+  class Dummy extends Context.Service<Dummy, { readonly current: () => Effect.Effect<ReturnType<typeof check>> }>()(
+    "@test/Dummy",
+  ) {}

-    const layer = Layer.effect(
-      Dummy,
-      Effect.gen(function* () {
-        return Dummy.of({
-          current: () => Effect.map(Effect.service(Logger.CurrentLoggers), check),
-        })
-      }),
-    )
+  const layer = Layer.effect(
+    Dummy,
+    Effect.gen(function* () {
+      return Dummy.of({
+        current: () => Effect.map(Effect.service(Logger.CurrentLoggers), check),
+      })
+    }),
+  )

-    const current = yield* Effect.promise(() => makeRuntime(Dummy, layer).runPromise((svc) => svc.current()))
+  const rt = makeRuntime(Dummy, layer)
+  const current = await rt.runPromise((svc) => svc.current())

-    expect(current.effectLogger).toBe(true)
-    expect(current.defaultLogger).toBe(false)
-  }),
-)
+  expect(current.effectLogger).toBe(true)
+  expect(current.defaultLogger).toBe(false)
+})

-it.live("AppRuntime also installs EffectLogger through Observability.layer", () =>
-  Effect.gen(function* () {
-    const current = yield* Effect.promise(() =>
-      AppRuntime.runPromise(Effect.map(Effect.service(Logger.CurrentLoggers), check)),
-    )
+test("AppRuntime also installs EffectLogger through Observability.layer", async () => {
+  const current = await AppRuntime.runPromise(Effect.map(Effect.service(Logger.CurrentLoggers), check))

-    expect(current.effectLogger).toBe(true)
-    expect(current.defaultLogger).toBe(false)
-  }),
-)
+  expect(current.effectLogger).toBe(true)
+  expect(current.defaultLogger).toBe(false)
+})

-it.live("AppRuntime attaches InstanceRef from ALS", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
-    const current = yield* Effect.promise(() =>
+test("AppRuntime attaches InstanceRef from ALS", async () => {
+  await using tmp = await tmpdir({ git: true })
+
+  const dir = await Instance.provide({
+    directory: tmp.path,
+    fn: () =>
      AppRuntime.runPromise(
        Effect.gen(function* () {
          return (yield* InstanceRef)?.directory
        }),
      ),
-    ).pipe(provideInstance(dir))
+  })

-    expect(current).toBe(dir)
-  }),
-)
+  expect(dir).toBe(tmp.path)
+})

-it.live("EffectBridge preserves logger and instance context across async boundaries", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
-    const result = yield* Effect.promise(() =>
+test("EffectBridge preserves logger and instance context across async boundaries", async () => {
+  await using tmp = await tmpdir({ git: true })
+
+  const result = await Instance.provide({
+    directory: tmp.path,
+    fn: () =>
      AppRuntime.runPromise(
        Effect.gen(function* () {
          const bridge = yield* EffectBridge.make()
@@ -89,10 +84,9 @@ it.live("EffectBridge preserves logger and instance context across async boundar
          )
        }),
      ),
-    ).pipe(provideInstance(dir))
+  })

-    expect(result.directory).toBe(dir)
-    expect(result.effectLogger).toBe(true)
-    expect(result.defaultLogger).toBe(false)
-  }),
-)
+  expect(result.directory).toBe(tmp.path)
+  expect(result.effectLogger).toBe(true)
+  expect(result.defaultLogger).toBe(false)
+})
@@ -1,65 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Config, ConfigProvider, Context, Effect, Layer, Option } from "effect"
-import { ConfigService } from "../../src/effect/config-service"
-import { it } from "../lib/effect"
-
-class TestConfig extends ConfigService.Service<TestConfig>()("@test/ConfigService", {
-  name: Config.string("NAME"),
-  token: Config.string("TOKEN").pipe(Config.option),
-  port: Config.number("PORT").pipe(Config.withDefault(3000)),
-}) {}
-
-const fromConfig = (input: Record<string, unknown>) =>
-  TestConfig.defaultLayer.pipe(Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown(input))))
-
-const readConfig = TestConfig.useSync((config) => config)
-
-describe("ConfigService", () => {
-  it.effect("defaultLayer parses values from the active ConfigProvider", () =>
-    Effect.gen(function* () {
-      const config = yield* readConfig.pipe(
-        Effect.provide(
-          fromConfig({
-            NAME: "kit",
-            TOKEN: "secret",
-            PORT: "4096",
-          }),
-        ),
-      )
-
-      expect(config.name).toBe("kit")
-      expect(config.token).toEqual(Option.some("secret"))
-      expect(config.port).toBe(4096)
-    }),
-  )
-
-  it.effect("defaultLayer applies Effect Config defaults", () =>
-    Effect.gen(function* () {
-      const config = yield* readConfig.pipe(Effect.provide(fromConfig({ NAME: "kit" })))
-
-      expect(config.name).toBe("kit")
-      expect(config.token).toEqual(Option.none())
-      expect(config.port).toBe(3000)
-    }),
-  )
-
-  it.effect("layer provides an already parsed service value", () =>
-    Effect.gen(function* () {
-      const config = yield* readConfig.pipe(
-        Effect.provide(
-          TestConfig.layer({
-            name: "direct",
-            token: Option.some("parsed"),
-            port: 9000,
-          }),
-        ),
-      )
-
-      expect(config).toEqual({
-        name: "direct",
-        token: Option.some("parsed"),
-        port: 9000,
-      } satisfies Context.Service.Shape<typeof TestConfig>)
-    }),
-  )
-})
@@ -1,393 +1,482 @@
-import { afterEach, expect } from "bun:test"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { $ } from "bun"
-import { Context, Deferred, Duration, Effect, Exit, Fiber, Layer } from "effect"
+import { afterEach, expect, test } from "bun:test"
+import { Deferred, Duration, Effect, Exit, Fiber, Layer, ManagedRuntime, Context } from "effect"
 import { InstanceState } from "@/effect/instance-state"
+import { InstanceRef } from "../../src/effect/instance-ref"
 import { Instance } from "../../src/project/instance"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"

-const it = testEffect(CrossSpawnSpawner.defaultLayer)
-
-const access = <A, E>(state: InstanceState.InstanceState<A, E>, dir: string) =>
-  InstanceState.get(state).pipe(provideInstance(dir))
-
-const tmpdirGitScoped = Effect.gen(function* () {
-  const dir = yield* tmpdirScoped({ git: true })
-  yield* Effect.promise(() => $`git commit --allow-empty --amend -m ${`root commit ${dir}`}`.cwd(dir).quiet())
-  return dir
-})
+async function access<A, E>(state: InstanceState.InstanceState<A, E>, dir: string) {
+  return Instance.provide({
+    directory: dir,
+    fn: () => Effect.runPromise(InstanceState.get(state)),
+  })
+}

 afterEach(async () => {
  await Instance.disposeAll()
 })

-it.live("InstanceState caches values per directory", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    let n = 0
-    const state = yield* InstanceState.make(() => Effect.sync(() => ({ n: ++n })))
+test("InstanceState caches values per directory", async () => {
+  await using tmp = await tmpdir()
+  let n = 0

-    const a = yield* access(state, dir)
-    const b = yield* access(state, dir)
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() => Effect.sync(() => ({ n: ++n })))

-    expect(a).toBe(b)
-    expect(n).toBe(1)
-  }),
-)
+        const a = yield* Effect.promise(() => access(state, tmp.path))
+        const b = yield* Effect.promise(() => access(state, tmp.path))

-it.live("InstanceState isolates directories", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped()
-    const two = yield* tmpdirScoped()
-    let n = 0
-    const state = yield* InstanceState.make((dir) => Effect.sync(() => ({ dir, n: ++n })))
+        expect(a).toBe(b)
+        expect(n).toBe(1)
+      }),
+    ),
+  )
+})

-    const a = yield* access(state, one)
-    const b = yield* access(state, two)
-    const c = yield* access(state, one)
+test("InstanceState isolates directories", async () => {
+  await using one = await tmpdir()
+  await using two = await tmpdir()
+  let n = 0

-    expect(a).toBe(c)
-    expect(a).not.toBe(b)
-    expect(n).toBe(2)
-  }),
-)
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((dir) => Effect.sync(() => ({ dir, n: ++n })))

-it.live("InstanceState invalidates on reload", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    const seen: string[] = []
-    let n = 0
-    const state = yield* InstanceState.make(() =>
-      Effect.acquireRelease(
-        Effect.sync(() => ({ n: ++n })),
-        (value) =>
-          Effect.sync(() => {
-            seen.push(String(value.n))
+        const a = yield* Effect.promise(() => access(state, one.path))
+        const b = yield* Effect.promise(() => access(state, two.path))
+        const c = yield* Effect.promise(() => access(state, one.path))
+
+        expect(a).toBe(c)
+        expect(a).not.toBe(b)
+        expect(n).toBe(2)
+      }),
+    ),
+  )
+})
+
+test("InstanceState invalidates on reload", async () => {
+  await using tmp = await tmpdir()
+  const seen: string[] = []
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() =>
+          Effect.acquireRelease(
+            Effect.sync(() => ({ n: ++n })),
+            (value) =>
+              Effect.sync(() => {
+                seen.push(String(value.n))
+              }),
+          ),
+        )
+
+        const a = yield* Effect.promise(() => access(state, tmp.path))
+        yield* Effect.promise(() => Instance.reload({ directory: tmp.path }))
+        const b = yield* Effect.promise(() => access(state, tmp.path))
+
+        expect(a).not.toBe(b)
+        expect(seen).toEqual(["1"])
+      }),
+    ),
+  )
+})
+
+test("InstanceState invalidates on disposeAll", async () => {
+  await using one = await tmpdir()
+  await using two = await tmpdir()
+  const seen: string[] = []
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) =>
+          Effect.acquireRelease(
+            Effect.sync(() => ({ dir: ctx.directory })),
+            (value) =>
+              Effect.sync(() => {
+                seen.push(value.dir)
+              }),
+          ),
+        )
+
+        yield* Effect.promise(() => access(state, one.path))
+        yield* Effect.promise(() => access(state, two.path))
+        yield* Effect.promise(() => Instance.disposeAll())
+
+        expect(seen.sort()).toEqual([one.path, two.path].sort())
+      }),
+    ),
+  )
+})
+
+test("InstanceState.get reads the current directory lazily", async () => {
+  await using one = await tmpdir()
+  await using two = await tmpdir()
+
+  interface Api {
+    readonly get: () => Effect.Effect<string>
+  }
+
+  class Test extends Context.Service<Test, Api>()("@test/InstanceStateLazy") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+        const get = InstanceState.get(state)
+
+        return Test.of({
+          get: Effect.fn("Test.get")(function* () {
+            return yield* get
          }),
-      ),
-    )
-
-    const a = yield* access(state, dir)
-    yield* Effect.promise(() => Instance.reload({ directory: dir }))
-    const b = yield* access(state, dir)
-
-    expect(a).not.toBe(b)
-    expect(seen).toEqual(["1"])
-  }),
-)
-
-it.live("InstanceState invalidates on disposeAll", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped()
-    const two = yield* tmpdirScoped()
-    const seen: string[] = []
-    const state = yield* InstanceState.make((ctx) =>
-      Effect.acquireRelease(
-        Effect.sync(() => ({ dir: ctx.directory })),
-        (value) =>
-          Effect.sync(() => {
-            seen.push(value.dir)
-          }),
-      ),
-    )
-
-    yield* access(state, one)
-    yield* access(state, two)
-    yield* Effect.promise(() => Instance.disposeAll())
-
-    expect(seen.sort()).toEqual([one, two].sort())
-  }),
-)
-
-it.live("InstanceState.get reads the current directory lazily", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped()
-    const two = yield* tmpdirScoped()
-
-    interface Api {
-      readonly get: () => Effect.Effect<string>
-    }
-
-    class Test extends Context.Service<Test, Api>()("@test/InstanceStateLazy") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
-          const get = InstanceState.get(state)
-
-          return Test.of({
-            get: Effect.fn("Test.get")(function* () {
-              return yield* get
-            }),
-          })
-        }),
-      )
-    }
-
-    yield* Effect.gen(function* () {
-      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
-      const b = yield* Test.use((svc) => svc.get()).pipe(provideInstance(two))
-
-      expect(a).toBe(one)
-      expect(b).toBe(two)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
-
-it.live("InstanceState preserves directory across async boundaries", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirGitScoped
-    const two = yield* tmpdirGitScoped
-    const three = yield* tmpdirGitScoped
-
-    interface Api {
-      readonly get: () => Effect.Effect<{ directory: string; worktree: string; project: string }>
-    }
-
-    class Test extends Context.Service<Test, Api>()("@test/InstanceStateAsync") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) =>
-            Effect.sync(() => ({
-              directory: ctx.directory,
-              worktree: ctx.worktree,
-              project: ctx.project.id,
-            })),
-          )
-
-          return Test.of({
-            get: Effect.fn("Test.get")(function* () {
-              yield* Effect.promise(() => Bun.sleep(1))
-              yield* Effect.sleep(Duration.millis(1))
-              for (let i = 0; i < 100; i++) {
-                yield* Effect.yieldNow
-              }
-              for (let i = 0; i < 100; i++) {
-                yield* Effect.promise(() => Promise.resolve())
-              }
-              yield* Effect.sleep(Duration.millis(2))
-              yield* Effect.promise(() => Bun.sleep(1))
-              return yield* InstanceState.get(state)
-            }),
-          })
-        }),
-      )
-    }
-
-    yield* Effect.gen(function* () {
-      const [a, b, c] = yield* Effect.all(
-        [one, two, three].map((dir) => Test.use((svc) => svc.get()).pipe(provideInstance(dir))),
-        { concurrency: "unbounded" },
-      )
-
-      expect(a).toEqual({ directory: one, worktree: one, project: a.project })
-      expect(b).toEqual({ directory: two, worktree: two, project: b.project })
-      expect(c).toEqual({ directory: three, worktree: three, project: c.project })
-      expect(a.project).not.toBe(b.project)
-      expect(a.project).not.toBe(c.project)
-      expect(b.project).not.toBe(c.project)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
-
-it.live("InstanceState survives high-contention concurrent access", () =>
-  Effect.gen(function* () {
-    const dirs = yield* Effect.all(
-      Array.from({ length: 20 }, () => tmpdirScoped()),
-      { concurrency: "unbounded" },
-    )
-
-    interface Api {
-      readonly get: () => Effect.Effect<string>
-    }
-
-    class Test extends Context.Service<Test, Api>()("@test/HighContention") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
-
-          return Test.of({
-            get: Effect.fn("Test.get")(function* () {
-              for (let i = 0; i < 10; i++) {
-                yield* Effect.promise(() => Bun.sleep(Math.random() * 3))
-                yield* Effect.yieldNow
-                yield* Effect.promise(() => Promise.resolve())
-              }
-              return yield* InstanceState.get(state)
-            }),
-          })
-        }),
-      )
-    }
-
-    yield* Effect.gen(function* () {
-      const results = yield* Effect.all(
-        dirs.map((dir) => Test.use((svc) => svc.get()).pipe(provideInstance(dir))),
-        { concurrency: "unbounded" },
-      )
-
-      expect(results).toEqual(dirs)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
-
-it.live("InstanceState correct after interleaved init and dispose", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped()
-    const two = yield* tmpdirScoped()
-
-    interface Api {
-      readonly get: () => Effect.Effect<string>
-    }
-
-    class Test extends Context.Service<Test, Api>()("@test/InterleavedDispose") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) =>
-            Effect.promise(async () => {
-              await Bun.sleep(5)
-              return ctx.directory
-            }),
-          )
-
-          return Test.of({
-            get: Effect.fn("Test.get")(function* () {
-              return yield* InstanceState.get(state)
-            }),
-          })
-        }),
-      )
-    }
-
-    yield* Effect.gen(function* () {
-      const a = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
-      expect(a).toBe(one)
-
-      const [, b] = yield* Effect.all(
-        [
-          Effect.promise(() => Instance.reload({ directory: one })),
-          Test.use((svc) => svc.get()).pipe(provideInstance(two)),
-        ],
-        { concurrency: "unbounded" },
-      )
-      expect(b).toBe(two)
-
-      const c = yield* Test.use((svc) => svc.get()).pipe(provideInstance(one))
-      expect(c).toBe(one)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
-
-it.live("InstanceState mutation in one directory does not leak to another", () =>
-  Effect.gen(function* () {
-    const one = yield* tmpdirScoped()
-    const two = yield* tmpdirScoped()
-    const state = yield* InstanceState.make(() => Effect.sync(() => ({ count: 0 })))
-
-    const s1 = yield* access(state, one)
-    s1.count = 42
-
-    const s2 = yield* access(state, two)
-    expect(s2.count).toBe(0)
-
-    const s1again = yield* access(state, one)
-    expect(s1again.count).toBe(42)
-    expect(s1again).toBe(s1)
-  }),
-)
-
-it.live("InstanceState dedupes concurrent lookups", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    let n = 0
-    const state = yield* InstanceState.make(() =>
-      Effect.promise(async () => {
-        n += 1
-        await Bun.sleep(10)
-        return { n }
+        })
      }),
    )
+  }

-    const [a, b] = yield* Effect.all([access(state, dir), access(state, dir)], { concurrency: "unbounded" })
-    expect(a).toBe(b)
-    expect(n).toBe(1)
-  }),
-)
+  const rt = ManagedRuntime.make(Test.layer)

-it.live("InstanceState survives deferred resume from the same instance context", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
+  try {
+    const a = await Instance.provide({
+      directory: one.path,
+      fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+    })
+    const b = await Instance.provide({
+      directory: two.path,
+      fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+    })

-    interface Api {
-      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
-    }
+    expect(a).toBe(one.path)
+    expect(b).toBe(two.path)
+  } finally {
+    await rt.dispose()
+  }
+})

-    class Test extends Context.Service<Test, Api>()("@test/DeferredResume") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+test("InstanceState preserves directory across async boundaries", async () => {
+  await using one = await tmpdir({ git: true })
+  await using two = await tmpdir({ git: true })
+  await using three = await tmpdir({ git: true })

-          return Test.of({
-            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
-              yield* Deferred.await(gate)
-              return yield* InstanceState.get(state)
-            }),
-          })
+  interface Api {
+    readonly get: () => Effect.Effect<{ directory: string; worktree: string; project: string }>
+  }
+
+  class Test extends Context.Service<Test, Api>()("@test/InstanceStateAsync") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) =>
+          Effect.sync(() => ({
+            directory: ctx.directory,
+            worktree: ctx.worktree,
+            project: ctx.project.id,
+          })),
+        )
+
+        return Test.of({
+          get: Effect.fn("Test.get")(function* () {
+            yield* Effect.promise(() => Bun.sleep(1))
+            yield* Effect.sleep(Duration.millis(1))
+            for (let i = 0; i < 100; i++) {
+              yield* Effect.yieldNow
+            }
+            for (let i = 0; i < 100; i++) {
+              yield* Effect.promise(() => Promise.resolve())
+            }
+            yield* Effect.sleep(Duration.millis(2))
+            yield* Effect.promise(() => Bun.sleep(1))
+            return yield* InstanceState.get(state)
+          }),
+        })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(Test.layer)
+
+  try {
+    const [a, b, c] = await Promise.all([
+      Instance.provide({
+        directory: one.path,
+        fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+      }),
+      Instance.provide({
+        directory: two.path,
+        fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+      }),
+      Instance.provide({
+        directory: three.path,
+        fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+      }),
+    ])
+
+    expect(a).toEqual({ directory: one.path, worktree: one.path, project: a.project })
+    expect(b).toEqual({ directory: two.path, worktree: two.path, project: b.project })
+    expect(c).toEqual({ directory: three.path, worktree: three.path, project: c.project })
+    expect(a.project).not.toBe(b.project)
+    expect(a.project).not.toBe(c.project)
+    expect(b.project).not.toBe(c.project)
+  } finally {
+    await rt.dispose()
+  }
+})
+
+test("InstanceState survives high-contention concurrent access", async () => {
+  const N = 20
+  const dirs = await Promise.all(Array.from({ length: N }, () => tmpdir()))
+
+  interface Api {
+    readonly get: () => Effect.Effect<string>
+  }
+
+  class Test extends Context.Service<Test, Api>()("@test/HighContention") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+        return Test.of({
+          get: Effect.fn("Test.get")(function* () {
+            // Interleave many async hops to maximize chance of ALS corruption
+            for (let i = 0; i < 10; i++) {
+              yield* Effect.promise(() => Bun.sleep(Math.random() * 3))
+              yield* Effect.yieldNow
+              yield* Effect.promise(() => Promise.resolve())
+            }
+            return yield* InstanceState.get(state)
+          }),
+        })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(Test.layer)
+
+  try {
+    const results = await Promise.all(
+      dirs.map((d) =>
+        Instance.provide({
+          directory: d.path,
+          fn: () => rt.runPromise(Test.use((svc) => svc.get())),
        }),
-      )
+      ),
+    )
+
+    for (let i = 0; i < N; i++) {
+      expect(results[i]).toBe(dirs[i].path)
    }
+  } finally {
+    await rt.dispose()
+    for (const d of dirs) await d[Symbol.asyncDispose]()
+  }
+})

-    yield* Effect.gen(function* () {
-      const gate = yield* Deferred.make<void>()
-      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstance(dir), Effect.forkScoped)
+test("InstanceState correct after interleaved init and dispose", async () => {
+  await using one = await tmpdir()
+  await using two = await tmpdir()

-      yield* Deferred.succeed(gate, undefined).pipe(provideInstance(dir))
-      const exit = yield* Fiber.await(fiber)
+  interface Api {
+    readonly get: () => Effect.Effect<string>
+  }

-      expect(Exit.isSuccess(exit)).toBe(true)
-      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
+  class Test extends Context.Service<Test, Api>()("@test/InterleavedDispose") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) =>
+          Effect.promise(async () => {
+            await Bun.sleep(5) // slow init
+            return ctx.directory
+          }),
+        )

-it.live("InstanceState survives deferred resume outside ALS when InstanceRef is set", () =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped({ git: true })
+        return Test.of({
+          get: Effect.fn("Test.get")(function* () {
+            return yield* InstanceState.get(state)
+          }),
+        })
+      }),
+    )
+  }

-    interface Api {
-      readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
+  const rt = ManagedRuntime.make(Test.layer)
+
+  try {
+    // Init both directories
+    const a = await Instance.provide({
+      directory: one.path,
+      fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+    })
+    expect(a).toBe(one.path)
+
+    // Dispose one directory, access the other concurrently
+    const [, b] = await Promise.all([
+      Instance.reload({ directory: one.path }),
+      Instance.provide({
+        directory: two.path,
+        fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+      }),
+    ])
+    expect(b).toBe(two.path)
+
+    // Re-access disposed directory - should get fresh state
+    const c = await Instance.provide({
+      directory: one.path,
+      fn: () => rt.runPromise(Test.use((svc) => svc.get())),
+    })
+    expect(c).toBe(one.path)
+  } finally {
+    await rt.dispose()
+  }
+})
+
+test("InstanceState mutation in one directory does not leak to another", async () => {
+  await using one = await tmpdir()
+  await using two = await tmpdir()
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() => Effect.sync(() => ({ count: 0 })))
+
+        // Mutate state in directory one
+        const s1 = yield* Effect.promise(() => access(state, one.path))
+        s1.count = 42
+
+        // Access directory two — should be independent
+        const s2 = yield* Effect.promise(() => access(state, two.path))
+        expect(s2.count).toBe(0)
+
+        // Confirm directory one still has the mutation
+        const s1again = yield* Effect.promise(() => access(state, one.path))
+        expect(s1again.count).toBe(42)
+        expect(s1again).toBe(s1) // same reference
+      }),
+    ),
+  )
+})
+
+test("InstanceState dedupes concurrent lookups", async () => {
+  await using tmp = await tmpdir()
+  let n = 0
+
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make(() =>
+          Effect.promise(async () => {
+            n += 1
+            await Bun.sleep(10)
+            return { n }
+          }),
+        )
+
+        const [a, b] = yield* Effect.promise(() => Promise.all([access(state, tmp.path), access(state, tmp.path)]))
+        expect(a).toBe(b)
+        expect(n).toBe(1)
+      }),
+    ),
+  )
+})
+
+test("InstanceState survives deferred resume from the same instance context", async () => {
+  await using tmp = await tmpdir({ git: true })
+
+  interface Api {
+    readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
+  }
+
+  class Test extends Context.Service<Test, Api>()("@test/DeferredResume") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+        return Test.of({
+          get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
+            yield* Deferred.await(gate)
+            return yield* InstanceState.get(state)
+          }),
+        })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(Test.layer)
+
+  try {
+    const gate = await Effect.runPromise(Deferred.make<void>())
+    const fiber = await Instance.provide({
+      directory: tmp.path,
+      fn: () => Promise.resolve(rt.runFork(Test.use((svc) => svc.get(gate)))),
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () => Effect.runPromise(Deferred.succeed(gate, void 0)),
+    })
+    const exit = await Effect.runPromise(Fiber.await(fiber))
+
+    expect(Exit.isSuccess(exit)).toBe(true)
+    if (Exit.isSuccess(exit)) {
+      expect(exit.value).toBe(tmp.path)
    }
+  } finally {
+    await rt.dispose()
+  }
+})

-    class Test extends Context.Service<Test, Api>()("@test/DeferredResumeOutside") {
-      static readonly layer = Layer.effect(
-        Test,
-        Effect.gen(function* () {
-          const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+test("InstanceState survives deferred resume outside ALS when InstanceRef is set", async () => {
+  await using tmp = await tmpdir({ git: true })

-          return Test.of({
-            get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
-              yield* Deferred.await(gate)
-              return yield* InstanceState.get(state)
-            }),
-          })
-        }),
-      )
+  interface Api {
+    readonly get: (gate: Deferred.Deferred<void>) => Effect.Effect<string>
+  }
+
+  class Test extends Context.Service<Test, Api>()("@test/DeferredResumeOutside") {
+    static readonly layer = Layer.effect(
+      Test,
+      Effect.gen(function* () {
+        const state = yield* InstanceState.make((ctx) => Effect.sync(() => ctx.directory))
+
+        return Test.of({
+          get: Effect.fn("Test.get")(function* (gate: Deferred.Deferred<void>) {
+            yield* Deferred.await(gate)
+            return yield* InstanceState.get(state)
+          }),
+        })
+      }),
+    )
+  }
+
+  const rt = ManagedRuntime.make(Test.layer)
+
+  try {
+    const gate = await Effect.runPromise(Deferred.make<void>())
+    // Provide InstanceRef so the fiber carries the context even when
+    // the deferred is resolved from outside Instance.provide ALS.
+    const fiber = await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        Promise.resolve(
+          rt.runFork(Test.use((svc) => svc.get(gate)).pipe(Effect.provideService(InstanceRef, Instance.current))),
+        ),
+    })
+
+    // Resume from outside any Instance.provide — ALS is NOT set here
+    await Effect.runPromise(Deferred.succeed(gate, void 0))
+    const exit = await Effect.runPromise(Fiber.await(fiber))
+
+    expect(Exit.isSuccess(exit)).toBe(true)
+    if (Exit.isSuccess(exit)) {
+      expect(exit.value).toBe(tmp.path)
    }
-
-    yield* Effect.gen(function* () {
-      const gate = yield* Deferred.make<void>()
-      const fiber = yield* Test.use((svc) => svc.get(gate)).pipe(provideInstance(dir), Effect.forkScoped)
-
-      yield* Deferred.succeed(gate, undefined)
-      const exit = yield* Fiber.await(fiber)
-
-      expect(Exit.isSuccess(exit)).toBe(true)
-      if (Exit.isSuccess(exit)) expect(exit.value).toBe(dir)
-    }).pipe(Effect.provide(Test.layer))
-  }),
-)
+  } finally {
+    await rt.dispose()
+  }
+})
@@ -1,49 +1,46 @@
-import { expect } from "bun:test"
+import { expect, test } from "bun:test"
 import { Effect, Layer, Context } from "effect"
 import { makeRuntime } from "../../src/effect/run-service"
-import { it } from "../lib/effect"

 class Shared extends Context.Service<Shared, { readonly id: number }>()("@test/Shared") {}

-it.live("makeRuntime shares dependent layers through the shared memo map", () =>
-  Effect.gen(function* () {
-    let n = 0
+test("makeRuntime shares dependent layers through the shared memo map", async () => {
+  let n = 0

-    const shared = Layer.effect(
-      Shared,
-      Effect.sync(() => {
-        n += 1
-        return Shared.of({ id: n })
-      }),
-    )
+  const shared = Layer.effect(
+    Shared,
+    Effect.sync(() => {
+      n += 1
+      return Shared.of({ id: n })
+    }),
+  )

-    class One extends Context.Service<One, { readonly get: () => Effect.Effect<number> }>()("@test/One") {}
-    const one = Layer.effect(
-      One,
-      Effect.gen(function* () {
-        const svc = yield* Shared
-        return One.of({
-          get: Effect.fn("One.get")(() => Effect.succeed(svc.id)),
-        })
-      }),
-    ).pipe(Layer.provide(shared))
+  class One extends Context.Service<One, { readonly get: () => Effect.Effect<number> }>()("@test/One") {}
+  const one = Layer.effect(
+    One,
+    Effect.gen(function* () {
+      const svc = yield* Shared
+      return One.of({
+        get: Effect.fn("One.get")(() => Effect.succeed(svc.id)),
+      })
+    }),
+  ).pipe(Layer.provide(shared))

-    class Two extends Context.Service<Two, { readonly get: () => Effect.Effect<number> }>()("@test/Two") {}
-    const two = Layer.effect(
-      Two,
-      Effect.gen(function* () {
-        const svc = yield* Shared
-        return Two.of({
-          get: Effect.fn("Two.get")(() => Effect.succeed(svc.id)),
-        })
-      }),
-    ).pipe(Layer.provide(shared))
+  class Two extends Context.Service<Two, { readonly get: () => Effect.Effect<number> }>()("@test/Two") {}
+  const two = Layer.effect(
+    Two,
+    Effect.gen(function* () {
+      const svc = yield* Shared
+      return Two.of({
+        get: Effect.fn("Two.get")(() => Effect.succeed(svc.id)),
+      })
+    }),
+  ).pipe(Layer.provide(shared))

-    const { runPromise: runOne } = makeRuntime(One, one)
-    const { runPromise: runTwo } = makeRuntime(Two, two)
+  const { runPromise: runOne } = makeRuntime(One, one)
+  const { runPromise: runTwo } = makeRuntime(Two, two)

-    expect(yield* Effect.promise(() => runOne((svc) => svc.get()))).toBe(1)
-    expect(yield* Effect.promise(() => runTwo((svc) => svc.get()))).toBe(1)
-    expect(n).toBe(1)
-  }),
-)
+  expect(await runOne((svc) => svc.get())).toBe(1)
+  expect(await runTwo((svc) => svc.get())).toBe(1)
+  expect(n).toBe(1)
+})
@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Deferred, Effect, Exit, Fiber, Ref, Scope } from "effect"
 import { Runner } from "@/effect/runner"
 import { it } from "../lib/effect"
@@ -115,16 +115,8 @@ describe("Runner", () => {
    Effect.gen(function* () {
      const s = yield* Scope.Scope
      const runner = Runner.make<string>(s)
-      const started = yield* Deferred.make<void>()
-      const fiber = yield* runner
-        .ensureRunning(
-          Effect.gen(function* () {
-            yield* Deferred.succeed(started, void 0)
-            return yield* Effect.never.pipe(Effect.as("never"))
-          }),
-        )
-        .pipe(Effect.forkChild)
-      yield* Deferred.await(started)
+      const fiber = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("never"))).pipe(Effect.forkChild)
+      yield* Effect.sleep("10 millis")
      expect(runner.busy).toBe(true)
      expect(runner.state._tag).toBe("Running")

@@ -198,52 +190,58 @@ describe("Runner", () => {
    }),
  )

-  it.live(
-    "cancel does not deadlock when replacement work starts before interrupted run exits",
-    Effect.gen(function* () {
-      const s = yield* Scope.Scope
-      const hit = yield* Deferred.make<void>()
-      const hold = yield* Deferred.make<void>()
-      const done = yield* Deferred.make<void>()
+  test("cancel does not deadlock when replacement work starts before interrupted run exits", async () => {
+    function defer() {
+      let resolve!: () => void
+      const promise = new Promise<void>((done) => {
+        resolve = done
+      })
+      return { promise, resolve }
+    }

-      yield* Effect.gen(function* () {
-        const runner = Runner.make<string>(s)
-        const first = Effect.never.pipe(
-          Effect.onInterrupt(() => Deferred.succeed(hit, undefined)),
-          Effect.ensuring(Deferred.await(hold)),
-          Effect.as("first"),
-        )
+    function fail(ms: number, msg: string) {
+      return new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error(msg)), ms)
+      })
+    }

-        const a = yield* runner.ensureRunning(first).pipe(Effect.exit, Effect.forkChild)
-        yield* Effect.sleep("10 millis")
-
-        const stop = yield* runner.cancel.pipe(Effect.forkChild)
-        yield* Deferred.await(hit).pipe(Effect.timeout("250 millis"))
-
-        const b = yield* runner.ensureRunning(Deferred.await(done).pipe(Effect.as("second"))).pipe(Effect.forkChild)
-        yield* Effect.yieldNow
-        expect(runner.busy).toBe(true)
-
-        yield* Deferred.succeed(hold, undefined)
-        const stopExit = yield* Fiber.await(stop).pipe(Effect.timeout("250 millis"))
-        expect(Exit.isSuccess(stopExit)).toBe(true)
-
-        expect(runner.busy).toBe(true)
-        yield* Deferred.succeed(done, undefined)
-        expect(yield* Fiber.join(b).pipe(Effect.timeout("250 millis"))).toBe("second")
-        expect(runner.busy).toBe(false)
-
-        const exit = yield* Fiber.join(a)
-        expect(Exit.isFailure(exit)).toBe(true)
-      }).pipe(
-        Effect.ensuring(
-          Effect.all([Deferred.succeed(hold, undefined), Deferred.succeed(done, undefined)], { discard: true }).pipe(
-            Effect.ignore,
-          ),
-        ),
+    const s = await Effect.runPromise(Scope.make())
+    const hit = defer()
+    const hold = defer()
+    const done = defer()
+    try {
+      const runner = Runner.make<string>(s)
+      const first = Effect.never.pipe(
+        Effect.onInterrupt(() => Effect.sync(() => hit.resolve())),
+        Effect.ensuring(Effect.promise(() => hold.promise)),
+        Effect.as("first"),
      )
-    }),
-  )
+
+      const a = Effect.runPromiseExit(runner.ensureRunning(first))
+      await Bun.sleep(10)
+
+      const stop = Effect.runPromise(runner.cancel)
+      await Promise.race([hit.promise, fail(250, "cancel did not interrupt running work")])
+
+      const b = Effect.runPromise(runner.ensureRunning(Effect.promise(() => done.promise).pipe(Effect.as("second"))))
+      expect(runner.busy).toBe(true)
+
+      hold.resolve()
+      await Promise.race([stop, fail(250, "cancel deadlocked while replacement run was active")])
+
+      expect(runner.busy).toBe(true)
+      done.resolve()
+      expect(await b).toBe("second")
+      expect(runner.busy).toBe(false)
+
+      const exit = await a
+      expect(Exit.isFailure(exit)).toBe(true)
+    } finally {
+      hold.resolve()
+      done.resolve()
+      await Promise.race([Effect.runPromise(Scope.close(s, Exit.void)), fail(1000, "runner scope did not close")])
+    }
+  })

  // --- shell semantics ---

@@ -263,25 +261,14 @@ describe("Runner", () => {
    Effect.gen(function* () {
      const s = yield* Scope.Scope
      const runner = Runner.make<string>(s)
-      const started = yield* Deferred.make<void>()
-      const fiber = yield* runner
-        .ensureRunning(
-          Effect.gen(function* () {
-            yield* Deferred.succeed(started, undefined)
-            return yield* Effect.never.pipe(Effect.as("x"))
-          }),
-        )
-        .pipe(Effect.forkChild)
-      yield* Deferred.await(started).pipe(Effect.timeout("250 millis"))
-      yield* Effect.gen(function* () {
-        while (runner.state._tag !== "Running") yield* Effect.yieldNow
-      }).pipe(Effect.timeout("250 millis"))
+      const fiber = yield* runner.ensureRunning(Effect.never.pipe(Effect.as("x"))).pipe(Effect.forkChild)
+      yield* Effect.sleep("10 millis")

      const exit = yield* runner.startShell(Effect.succeed("nope")).pipe(Effect.exit)
      expect(Exit.isFailure(exit)).toBe(true)

      yield* runner.cancel
-      yield* Fiber.await(fiber).pipe(Effect.timeout("250 millis"))
+      yield* Fiber.await(fiber)
    }),
  )

@@ -1,18 +1,18 @@
-import { afterAll, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
+import { afterAll, afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
 import path from "path"
 import { pathToFileURL } from "url"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"

 const disableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
 process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "1"

 const { Plugin } = await import("../../src/plugin/index")
-const it = testEffect(Layer.mergeAll(Plugin.defaultLayer, CrossSpawnSpawner.defaultLayer))
-const systemHook = "experimental.chat.system.transform"
+const { Instance } = await import("../../src/project/instance")
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})

 afterAll(() => {
  if (disableDefault === undefined) {
@@ -22,81 +22,95 @@ afterAll(() => {
  process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = disableDefault
 })

-function withProject<A, E, R>(source: string, self: Effect.Effect<A, E, R>) {
-  return provideTmpdirInstance((dir) =>
-    Effect.gen(function* () {
+async function project(source: string) {
+  return tmpdir({
+    init: async (dir) => {
      const file = path.join(dir, "plugin.ts")
-      yield* Effect.all(
-        [
-          Effect.promise(() => Bun.write(file, source)),
-          Effect.promise(() =>
-            Bun.write(
-              path.join(dir, "opencode.json"),
-              JSON.stringify(
-                {
-                  $schema: "https://opencode.ai/config.json",
-                  plugin: [pathToFileURL(file).href],
-                },
-                null,
-                2,
-              ),
-            ),
-          ),
-        ],
-        { discard: true, concurrency: 2 },
+      await Bun.write(file, source)
+      await Bun.write(
+        path.join(dir, "opencode.json"),
+        JSON.stringify(
+          {
+            $schema: "https://opencode.ai/config.json",
+            plugin: [pathToFileURL(file).href],
+          },
+          null,
+          2,
+        ),
      )
-      return yield* self
-    }),
-  )
+    },
+  })
 }

-const triggerSystemTransform = Effect.fn("PluginTriggerTest.triggerSystemTransform")(function* () {
-  const plugin = yield* Plugin.Service
-  const out = { system: [] as string[] }
-  yield* plugin.trigger(
-    systemHook,
-    {
-      model: {
-        providerID: ProviderID.anthropic,
-        modelID: ModelID.make("claude-sonnet-4-6"),
-      },
-    },
-    out,
-  )
-  return out.system
-})
-
 describe("plugin.trigger", () => {
-  it.live("runs synchronous hooks without crashing", () =>
-    withProject(
+  test("runs synchronous hooks without crashing", async () => {
+    await using tmp = await project(
      [
        "export default async () => ({",
-        `  ${JSON.stringify(systemHook)}: (_input, output) => {`,
+        '  "experimental.chat.system.transform": (_input, output) => {',
        '    output.system.unshift("sync")',
        "  },",
        "})",
        "",
      ].join("\n"),
-      Effect.gen(function* () {
-        expect(yield* triggerSystemTransform()).toEqual(["sync"])
-      }),
-    ),
-  )
+    )

-  it.live("awaits asynchronous hooks", () =>
-    withProject(
+    const out = await Instance.provide({
+      directory: tmp.path,
+      fn: async () =>
+        Effect.gen(function* () {
+          const plugin = yield* Plugin.Service
+          const out = { system: [] as string[] }
+          yield* plugin.trigger(
+            "experimental.chat.system.transform",
+            {
+              model: {
+                providerID: "anthropic",
+                modelID: "claude-sonnet-4-6",
+              } as any,
+            },
+            out,
+          )
+          return out
+        }).pipe(Effect.provide(Plugin.defaultLayer), Effect.runPromise),
+    })
+
+    expect(out.system).toEqual(["sync"])
+  })
+
+  test("awaits asynchronous hooks", async () => {
+    await using tmp = await project(
      [
        "export default async () => ({",
-        `  ${JSON.stringify(systemHook)}: async (_input, output) => {`,
+        '  "experimental.chat.system.transform": async (_input, output) => {',
        "    await Bun.sleep(1)",
        '    output.system.unshift("async")',
        "  },",
        "})",
        "",
      ].join("\n"),
-      Effect.gen(function* () {
-        expect(yield* triggerSystemTransform()).toEqual(["async"])
-      }),
-    ),
-  )
+    )
+
+    const out = await Instance.provide({
+      directory: tmp.path,
+      fn: async () =>
+        Effect.gen(function* () {
+          const plugin = yield* Plugin.Service
+          const out = { system: [] as string[] }
+          yield* plugin.trigger(
+            "experimental.chat.system.transform",
+            {
+              model: {
+                providerID: "anthropic",
+                modelID: "claude-sonnet-4-6",
+              } as any,
+            },
+            out,
+          )
+          return out
+        }).pipe(Effect.provide(Plugin.defaultLayer), Effect.runPromise),
+    })
+
+    expect(out.system).toEqual(["async"])
+  })
 })
@@ -0,0 +1,109 @@
+import { afterAll, afterEach, describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../fixture/fixture"
+
+const disableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
+process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "1"
+
+const { Flag } = await import("@opencode-ai/core/flag/flag")
+const { Plugin } = await import("../../src/plugin/index")
+const { Workspace } = await import("../../src/control-plane/workspace")
+const { Instance } = await import("../../src/project/instance")
+
+const experimental = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
+
+Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+afterAll(() => {
+  if (disableDefault === undefined) {
+    delete process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
+  } else {
+    process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = disableDefault
+  }
+
+  Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = experimental
+})
+
+describe("plugin.workspace", () => {
+  test("plugin can install a workspace adapter", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        const type = `plug-${Math.random().toString(36).slice(2)}`
+        const file = path.join(dir, "plugin.ts")
+        const mark = path.join(dir, "created.json")
+        const space = path.join(dir, "space")
+        await Bun.write(
+          file,
+          [
+            "export default async ({ experimental_workspace }) => {",
+            `  experimental_workspace.register(${JSON.stringify(type)}, {`,
+            '    name: "plug",',
+            '    description: "plugin workspace adapter",',
+            "    configure(input) {",
+            `      return { ...input, name: "plug", branch: "plug/main", directory: ${JSON.stringify(space)} }`,
+            "    },",
+            "    async create(input) {",
+            `      await Bun.write(${JSON.stringify(mark)}, JSON.stringify(input))`,
+            "    },",
+            "    async remove() {},",
+            "    target(input) {",
+            '      return { type: "local", directory: input.directory }',
+            "    },",
+            "  })",
+            "  return {}",
+            "}",
+            "",
+          ].join("\n"),
+        )
+
+        await Bun.write(
+          path.join(dir, "opencode.json"),
+          JSON.stringify(
+            {
+              $schema: "https://opencode.ai/config.json",
+              plugin: [pathToFileURL(file).href],
+            },
+            null,
+            2,
+          ),
+        )
+
+        return { mark, space, type }
+      },
+    })
+
+    const info = await Instance.provide({
+      directory: tmp.path,
+      fn: async () =>
+        Effect.gen(function* () {
+          const plugin = yield* Plugin.Service
+          yield* plugin.init()
+          return Workspace.create({
+            type: tmp.extra.type,
+            branch: null,
+            extra: { key: "value" },
+            projectID: Instance.project.id,
+          })
+        }).pipe(Effect.provide(Plugin.defaultLayer), Effect.runPromise),
+    })
+
+    expect(info.type).toBe(tmp.extra.type)
+    expect(info.name).toBe("plug")
+    expect(info.branch).toBe("plug/main")
+    expect(info.directory).toBe(tmp.extra.space)
+    expect(info.extra).toEqual({ key: "value" })
+    expect(JSON.parse(await Bun.file(tmp.extra.mark).text())).toMatchObject({
+      type: tmp.extra.type,
+      name: "plug",
+      branch: "plug/main",
+      directory: tmp.extra.space,
+      extra: { key: "value" },
+    })
+  })
+})
@@ -1,109 +0,0 @@
-import { afterAll, afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import path from "path"
-import { pathToFileURL } from "url"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const disableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
-process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "1"
-
-const { Flag } = await import("@opencode-ai/core/flag/flag")
-const { Plugin } = await import("../../src/plugin/index")
-const { Workspace } = await import("../../src/control-plane/workspace")
-const { Instance } = await import("../../src/project/instance")
-const it = testEffect(Layer.mergeAll(Plugin.defaultLayer, Workspace.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-const experimental = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
-
-Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-afterAll(() => {
-  if (disableDefault === undefined) {
-    delete process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS
-  } else {
-    process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = disableDefault
-  }
-
-  Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = experimental
-})
-
-describe("plugin.workspace", () => {
-  it.live("plugin can install a workspace adaptor", () =>
-    provideTmpdirInstance((dir) =>
-      Effect.gen(function* () {
-        const type = `plug-${Math.random().toString(36).slice(2)}`
-        const file = path.join(dir, "plugin.ts")
-        const mark = path.join(dir, "created.json")
-        const space = path.join(dir, "space")
-        yield* Effect.promise(() =>
-          Bun.write(
-            file,
-            [
-              "export default async ({ experimental_workspace }) => {",
-              `  experimental_workspace.register(${JSON.stringify(type)}, {`,
-              '    name: "plug",',
-              '    description: "plugin workspace adaptor",',
-              "    configure(input) {",
-              `      return { ...input, name: "plug", branch: "plug/main", directory: ${JSON.stringify(space)} }`,
-              "    },",
-              "    async create(input) {",
-              `      await Bun.write(${JSON.stringify(mark)}, JSON.stringify(input))`,
-              "    },",
-              "    async remove() {},",
-              "    target(input) {",
-              '      return { type: "local", directory: input.directory }',
-              "    },",
-              "  })",
-              "  return {}",
-              "}",
-              "",
-            ].join("\n"),
-          ),
-        )
-
-        yield* Effect.promise(() =>
-          Bun.write(
-            path.join(dir, "opencode.json"),
-            JSON.stringify(
-              {
-                $schema: "https://opencode.ai/config.json",
-                plugin: [pathToFileURL(file).href],
-              },
-              null,
-              2,
-            ),
-          ),
-        )
-
-        const plugin = yield* Plugin.Service
-        yield* plugin.init()
-        const workspace = yield* Workspace.Service
-        const info = yield* workspace.create({
-          type,
-          branch: null,
-          extra: { key: "value" },
-          projectID: Instance.project.id,
-        })
-
-        expect(info.type).toBe(type)
-        expect(info.name).toBe("plug")
-        expect(info.branch).toBe("plug/main")
-        expect(info.directory).toBe(space)
-        expect(info.extra).toEqual({ key: "value" })
-        expect(JSON.parse(yield* Effect.promise(() => Bun.file(mark).text()))).toMatchObject({
-          type,
-          name: "plug",
-          branch: "plug/main",
-          directory: space,
-          extra: { key: "value" },
-        })
-      }),
-    ),
-  )
-})
@@ -1,15 +0,0 @@
-# Server Test Guide
-
-Use these patterns for server and HttpApi middleware tests in this directory.
-
- Prefer focused middleware tests with tiny fake routes over full API route trees when testing routing, context, proxying, or middleware policy.
- Use `testEffect(...)` with `NodeHttpServer.layerTest` for the primary in-test server and make relative `HttpClient` requests against it.
- Use `HttpRouter.add(...)` probe routes that expose the context under test, such as `WorkspaceRouteContext`, `InstanceRef`, or `WorkspaceRef`.
- Compose middleware in the same order as production when testing interactions, for example `instanceRouterMiddleware.combine(workspaceRouterMiddleware)`.
- For secondary upstream servers, build Effect `NodeHttpServer.layer(...)` into the current test scope with `Layer.build(...)` so the listener stays alive until the test scope exits.
- Avoid `Bun.serve` when testing Effect HTTP middleware. Keep the test in the Effect HTTP stack unless the production path being tested is Bun-specific.
- For WebSocket paths, use `Socket.makeWebSocket(...)` from the test client and assert protocol forwarding or frame relay when relevant.
- Use scoped test layers for flags, database reset, and other global mutable state. Restore flags and reset state in finalizers.
- Use `tmpdirScoped({ git: true })` plus `Project.use.fromDirectory(dir)` for project-backed requests.
- If a test needs persisted state without matching runtime state, keep direct database setup inside a narrowly named helper that explains that state.
- Add comments for non-obvious test topology, especially tests involving both the local test server and a fake upstream server.
@@ -1,103 +0,0 @@
-import { NodeHttpServer } from "@effect/platform-node"
-import { describe, expect } from "bun:test"
-import { Effect, Layer, Option, Schema } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter } from "effect/unstable/http"
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
-import {
-  Authorization,
-  ServerAuthConfig,
-  authorizationLayer,
-} from "../../src/server/routes/instance/httpapi/middleware/authorization"
-import { testEffect } from "../lib/effect"
-
-const Api = HttpApi.make("test-authorization").add(
-  HttpApiGroup.make("test")
-    .add(
-      HttpApiEndpoint.get("probe", "/probe", {
-        success: Schema.String,
-      }),
-    )
-    .middleware(Authorization),
-)
-
-const handlers = HttpApiBuilder.group(Api, "test", (handlers) => handlers.handle("probe", () => Effect.succeed("ok")))
-
-const apiLayer = HttpRouter.serve(
-  HttpApiBuilder.layer(Api).pipe(Layer.provide(handlers), Layer.provide(authorizationLayer)),
-  { disableListenLog: true, disableLogger: true },
-).pipe(Layer.provideMerge(NodeHttpServer.layerTest))
-
-const noAuthLayer = ServerAuthConfig.layer({ password: Option.none(), username: "opencode" })
-const secretLayer = ServerAuthConfig.layer({ password: Option.some("secret"), username: "opencode" })
-const kitSecretLayer = ServerAuthConfig.layer({ password: Option.some("secret"), username: "kit" })
-
-const it = testEffect(apiLayer.pipe(Layer.provide(noAuthLayer)))
-const itSecret = testEffect(apiLayer.pipe(Layer.provide(secretLayer)))
-const itKitSecret = testEffect(apiLayer.pipe(Layer.provide(kitSecretLayer)))
-
-const basic = (username: string, password: string) =>
-  `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-
-const token = (username: string, password: string) => Buffer.from(`${username}:${password}`).toString("base64")
-
-const getProbe = (headers?: Record<string, string>) =>
-  HttpClientRequest.get("/probe").pipe(
-    headers ? HttpClientRequest.setHeaders(headers) : (request) => request,
-    HttpClient.execute,
-  )
-
-describe("HttpApi authorization middleware", () => {
-  it.live("allows requests when server password is not configured", () =>
-    Effect.gen(function* () {
-      const response = yield* getProbe()
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toBe("ok")
-    }),
-  )
-
-  itSecret.live("requires configured password for basic auth", () =>
-    Effect.gen(function* () {
-      const [missing, badPassword, good] = yield* Effect.all(
-        [
-          getProbe(),
-          getProbe({ authorization: basic("opencode", "wrong") }),
-          getProbe({ authorization: basic("opencode", "secret") }),
-        ],
-        { concurrency: "unbounded" },
-      )
-
-      expect(missing.status).toBe(401)
-      expect(badPassword.status).toBe(401)
-      expect(good.status).toBe(200)
-    }),
-  )
-
-  itKitSecret.live("respects configured basic auth username", () =>
-    Effect.gen(function* () {
-      const [defaultUser, configuredUser] = yield* Effect.all(
-        [getProbe({ authorization: basic("opencode", "secret") }), getProbe({ authorization: basic("kit", "secret") })],
-        { concurrency: "unbounded" },
-      )
-
-      expect(defaultUser.status).toBe(401)
-      expect(configuredUser.status).toBe(200)
-    }),
-  )
-
-  itSecret.live("accepts auth token query credentials", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClient.get(`/probe?auth_token=${encodeURIComponent(token("opencode", "secret"))}`)
-
-      expect(response.status).toBe(200)
-    }),
-  )
-
-  itSecret.live("rejects malformed auth token query credentials", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClient.get("/probe?auth_token=not-base64")
-
-      expect(response.status).toBe(401)
-    }),
-  )
-})
@@ -2,14 +2,11 @@ import { afterEach, describe, expect, test } from "bun:test"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { Instance } from "../../src/project/instance"
 import { ControlPaths } from "../../src/server/routes/instance/httpapi/groups/control"
-import { FilePaths } from "../../src/server/routes/instance/httpapi/groups/file"
+import { FileApi, FilePaths } from "../../src/server/routes/instance/httpapi/groups/file"
 import { GlobalPaths } from "../../src/server/routes/instance/httpapi/groups/global"
 import { PublicApi } from "../../src/server/routes/instance/httpapi/public"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
 import { Server } from "../../src/server/server"
 import * as Log from "@opencode-ai/core/util/log"
-import { ConfigProvider, Layer } from "effect"
-import { HttpRouter } from "effect/unstable/http"
 import { OpenApi } from "effect/unstable/httpapi"
 import { resetDatabase } from "../fixture/db"
 import { tmpdir } from "../fixture/fixture"
@@ -33,26 +30,7 @@ function app(input?: { password?: string; username?: string }) {
  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
  Flag.OPENCODE_SERVER_PASSWORD = input?.password
  Flag.OPENCODE_SERVER_USERNAME = input?.username
-
-  const handler = HttpRouter.toWebHandler(
-    ExperimentalHttpApiServer.routes.pipe(
-      Layer.provide(
-        ConfigProvider.layer(
-          ConfigProvider.fromUnknown({
-            OPENCODE_SERVER_PASSWORD: input?.password,
-            OPENCODE_SERVER_USERNAME: input?.username,
-          }),
-        ),
-      ),
-    ),
-    { disableLogger: true },
-  ).handler
-  return {
-    fetch: (request: Request) => handler(request, ExperimentalHttpApiServer.context),
-    request(input: string | URL | Request, init?: RequestInit) {
-      return this.fetch(input instanceof Request ? input : new Request(new URL(input, "http://localhost"), init))
-    },
-  }
+  return Server.Default().app
 }

 function openApiRouteKeys(spec: { paths: Record<string, Partial<Record<(typeof methods)[number], unknown>>> }) {
@@ -116,9 +94,9 @@ type RequestBody = {
  required?: boolean
 }

-function parameterKey(param: unknown): string | undefined {
-  if (!param || typeof param !== "object" || !("in" in param) || !("name" in param)) return undefined
-  if (typeof param.in !== "string" || typeof param.name !== "string") return undefined
+function parameterKey(param: unknown) {
+  if (!param || typeof param !== "object" || !("in" in param) || !("name" in param)) return
+  if (typeof param.in !== "string" || typeof param.name !== "string") return
  return `${param.in}:${param.name}:${"required" in param && param.required === true}`
 }

@@ -127,29 +105,27 @@ function parameterSchema(input: {
  path: string
  method: (typeof methods)[number]
  name: string
-}): unknown {
+}) {
  const param = input.spec.paths[input.path]?.[input.method]?.parameters?.find(
    (param) => !!param && typeof param === "object" && "name" in param && param.name === input.name,
  )
-  if (!param || typeof param !== "object" || !("schema" in param)) return undefined
+  if (!param || typeof param !== "object" || !("schema" in param)) return
  return param.schema
 }

 function requestBodyKey(spec: OpenApiSpec, body: unknown) {
  if (!body || typeof body !== "object" || !("content" in body)) return ""
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Guarded above; test helper only needs this OpenAPI subset.
  const requestBody = body as RequestBody
  return JSON.stringify({
    required: requestBody.required === true,
    content: Object.entries(requestBody.content ?? {})
-      .map(([type, value]) => [type, requestBodySchemaKind(spec, value.schema)] as const)
-      .sort(([left], [right]) => left.localeCompare(right)),
+      .map(([type, value]) => [type, requestBodySchemaKind(spec, value.schema)])
+      .sort(),
  })
 }

 function requestBodySchemaKind(spec: OpenApiSpec, schema: OpenApiSchema | undefined) {
  if (!schema) return ""
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- `$ref` lookup is constrained to OpenAPI schema components in this test helper.
  const resolved = (
    schema.$ref ? spec.components?.schemas?.[schema.$ref.replace("#/components/schemas/", "")] : schema
  ) as OpenApiSchema | undefined
@@ -166,7 +142,6 @@ function responseContentTypes(input: {
 }) {
  const responses = input.spec.paths[input.path]?.[input.method]?.responses
  if (!responses || typeof responses !== "object" || !(input.status in responses)) return []
-  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Guarded dynamic OpenAPI response lookup.
  const response = (responses as Record<string, unknown>)[input.status]
  if (!response || typeof response !== "object" || !("content" in response)) return []
  const content = (response as { content?: unknown }).content
@@ -1,64 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { Flag } from "@opencode-ai/core/flag/flag"
-import { describe, expect } from "bun:test"
-import { Config, Effect, Layer } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { resetDatabase } from "../fixture/db"
-import { testEffect } from "../lib/effect"
-
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const original = {
-      OPENCODE_EXPERIMENTAL_HTTPAPI: Flag.OPENCODE_EXPERIMENTAL_HTTPAPI,
-      OPENCODE_SERVER_PASSWORD: Flag.OPENCODE_SERVER_PASSWORD,
-    }
-    Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
-    Flag.OPENCODE_SERVER_PASSWORD = "secret"
-    yield* Effect.promise(() => resetDatabase())
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = original.OPENCODE_EXPERIMENTAL_HTTPAPI
-        Flag.OPENCODE_SERVER_PASSWORD = original.OPENCODE_SERVER_PASSWORD
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
-  ExperimentalHttpApiServer.routes,
-  { disableListenLog: true, disableLogger: true },
-)
-
-const it = testEffect(
-  Layer.mergeAll(
-    testStateLayer,
-    servedRoutes.pipe(
-      Layer.provide(Socket.layerWebSocketConstructorGlobal),
-      Layer.provideMerge(NodeHttpServer.layerTest),
-      Layer.provideMerge(NodeServices.layer),
-    ),
-  ),
-)
-
-describe("HttpApi CORS", () => {
-  it.live("allows browser preflight requests without credentials", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClientRequest.options(InstancePaths.path).pipe(
-        HttpClientRequest.setHeaders({
-          origin: "http://localhost:3000",
-          "access-control-request-method": "GET",
-          "access-control-request-headers": "authorization",
-        }),
-        HttpClient.execute,
-      )
-
-      expect(response.status).toBe(204)
-      expect(response.headers["access-control-allow-origin"]).toBe("http://localhost:3000")
-      expect(response.headers["access-control-allow-headers"]).toBe("authorization")
-    }),
-  )
-})
@@ -11,9 +11,9 @@ void Log.init({ print: false })

 const original = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI

-function app(experimental = true) {
-  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = experimental
-  return experimental ? Server.Default().app : Server.Legacy().app
+function app() {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
+  return Server.Default().app
 }

 async function readFirstChunk(response: Response) {
@@ -45,13 +45,4 @@ describe("event HttpApi bridge", () => {
    expect(response.headers.get("x-content-type-options")).toBe("nosniff")
    expect(await readFirstChunk(response)).toContain('data: {"type":"server.connected","properties":{}}\n\n')
  })
-
-  test("matches legacy first event frame", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-opencode-directory": tmp.path }
-    const legacy = await app(false).request(EventPaths.event, { headers })
-    const effect = await app(true).request(EventPaths.event, { headers })
-
-    expect(await readFirstChunk(effect)).toBe(await readFirstChunk(legacy))
-  })
 })
--- a/Show More
+++ b/Show More