handle all events

fix(core): run sessions with the same directory they were created with
2026-04-30 10:43:06 -04:00 · 2026-04-30 10:43:05 -04:00
67 changed files with 2428 additions and 5930 deletions
@@ -1,7 +1,6 @@
 {
  "$schema": "https://opencode.ai/config.json",
  "provider": {},
-  "plugin": ["../packages/opencode/src/control-plane/dev/debug-workspace-plugin.ts"],
  "permission": {
    "edit": {
      "packages/opencode/migration/*": "deny",
@@ -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",
@@ -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))

@@ -1 +0,0 @@
-ALTER TABLE `event_sequence` ADD `owner_id` text;
@@ -2,7 +2,7 @@ import { useDialog } from "@tui/ui/dialog"
 import { DialogSelect } from "@tui/ui/dialog-select"
 import { useRoute } from "@tui/context/route"
 import { useSync } from "@tui/context/sync"
-import { createMemo, createResource, createSignal, onMount, type JSX } from "solid-js"
+import { createMemo, createResource, createSignal, onMount } from "solid-js"
 import { Locale } from "@/util/locale"
 import { useProject } from "@tui/context/project"
 import { useKeybind } from "../context/keybind"
@@ -10,13 +10,15 @@ import { useTheme } from "../context/theme"
 import { useSDK } from "../context/sdk"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { DialogSessionRename } from "./dialog-session-rename"
+import { Keybind } from "@/util/keybind"
 import { createDebouncedSignal } from "../util/signal"
 import { useToast } from "../ui/toast"
-import { openWorkspaceSelect, type WorkspaceSelection, warpWorkspaceSession } from "./dialog-workspace-create"
+import { DialogWorkspaceCreate, openWorkspaceSession, restoreWorkspaceSession } from "./dialog-workspace-create"
 import { Spinner } from "./spinner"
 import { errorMessage } from "@/util/error"
 import { DialogSessionDeleteFailed } from "./dialog-session-delete-failed"
-import { WorkspaceLabel } from "./workspace-label"
+
+type WorkspaceStatus = "connected" | "connecting" | "disconnected" | "error"

 export function DialogSessionList() {
  const dialog = useDialog()
@@ -42,51 +44,26 @@ export function DialogSessionList() {
  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
  const sessions = createMemo(() => searchResults() ?? sync.data.session)

+  function createWorkspace() {
+    dialog.replace(() => (
+      <DialogWorkspaceCreate
+        onSelect={(workspaceID) =>
+          openWorkspaceSession({
+            dialog,
+            route,
+            sdk,
+            sync,
+            toast,
+            workspaceID,
+          })
+        }
+      />
+    ))
+  }
+
  function recover(session: NonNullable<ReturnType<typeof sessions>[number]>) {
    const workspace = project.workspace.get(session.workspaceID!)
    const list = () => dialog.replace(() => <DialogSessionList />)
-    const warp = async (selection: WorkspaceSelection) => {
-      if (selection.type === "none") {
-        await warpWorkspaceSession({
-          dialog,
-          sdk,
-          sync,
-          project,
-          toast,
-          workspaceID: null,
-          sessionID: session.id,
-          done: list,
-        })
-        return
-      }
-      const workspaceID = await (async () => {
-        if (selection.type === "existing") return selection.workspaceID
-        const result = await sdk.client.experimental.workspace
-          .create({ type: selection.workspaceType, branch: null })
-          .catch(() => undefined)
-        const workspace = result?.data
-        if (!workspace) {
-          toast.show({
-            message: `Failed to create workspace: ${errorMessage(result?.error ?? "no response")}`,
-            variant: "error",
-          })
-          return
-        }
-        await project.workspace.sync()
-        return workspace.id
-      })()
-      if (!workspaceID) return
-      await warpWorkspaceSession({
-        dialog,
-        sdk,
-        sync,
-        project,
-        toast,
-        workspaceID,
-        sessionID: session.id,
-        done: list,
-      })
-    }
    dialog.replace(() => (
      <DialogSessionDeleteFailed
        session={session.title}
@@ -113,15 +90,22 @@ export function DialogSessionList() {
          return true
        }}
        onRestore={() => {
-          void openWorkspaceSelect({
-            dialog,
-            sdk,
-            sync,
-            toast,
-            onSelect: (selection) => {
-              void warp(selection)
-            },
-          })
+          dialog.replace(() => (
+            <DialogWorkspaceCreate
+              onSelect={(workspaceID) =>
+                restoreWorkspaceSession({
+                  dialog,
+                  sdk,
+                  sync,
+                  project,
+                  toast,
+                  workspaceID,
+                  sessionID: session.id,
+                  done: list,
+                })
+              }
+            />
+          ))
          return false
        }}
      />
@@ -140,17 +124,30 @@ export function DialogSessionList() {
      .map((x) => {
        const workspace = x.workspaceID ? project.workspace.get(x.workspaceID) : undefined

-        let footer: JSX.Element | string = ""
+        let workspaceStatus: WorkspaceStatus | null = null
+        if (x.workspaceID) {
+          workspaceStatus = project.workspace.status(x.workspaceID) || "error"
+        }
+
+        let footer = ""
        if (Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) {
          if (x.workspaceID) {
-            footer = workspace ? (
-              <WorkspaceLabel
-                type={workspace.type}
-                name={workspace.name}
-                status={project.workspace.status(x.workspaceID) ?? "error"}
-              />
-            ) : (
-              <WorkspaceLabel type="unknown" name={x.workspaceID} status="error" />
+            let desc = "unknown"
+            if (workspace) {
+              desc = `${workspace.type}: ${workspace.name}`
+            }
+
+            footer = (
+              <>
+                {desc}{" "}
+                <span
+                  style={{
+                    fg: workspaceStatus === "connected" ? theme.success : theme.error,
+                  }}
+                >
+                  ●
+                </span>
+              </>
            )
          }
        } else {
@@ -253,6 +250,15 @@ export function DialogSessionList() {
            dialog.replace(() => <DialogSessionRename session={option.value} />)
          },
        },
+        {
+          keybind: Keybind.parse("ctrl+w")[0],
+          title: "new workspace",
+          side: "right",
+          disabled: !Flag.OPENCODE_EXPERIMENTAL_WORKSPACES,
+          onTrigger: () => {
+            createWorkspace()
+          },
+        },
      ]}
    />
  )
@@ -1,9 +1,11 @@
-import type { Workspace } from "@opencode-ai/sdk/v2"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
 import { useDialog } from "@tui/ui/dialog"
-import { DialogSelect, type DialogSelectOption } from "@tui/ui/dialog-select"
+import { DialogSelect } from "@tui/ui/dialog-select"
+import { useRoute } from "@tui/context/route"
 import { useSync } from "@tui/context/sync"
 import { useProject } from "@tui/context/project"
 import { createMemo, createSignal, onMount } from "solid-js"
+import { setTimeout as sleep } from "node:timers/promises"
 import { errorMessage } from "@/util/error"
 import { useSDK } from "../context/sdk"
 import { useToast } from "../ui/toast"
@@ -14,223 +16,184 @@ type Adaptor = {
  description: string
 }

-export type WorkspaceSelection =
-  | {
-      type: "none"
-    }
-  | {
-      type: "new"
-      workspaceType: string
-      workspaceName: string
-    }
-  | {
-      type: "existing"
-      workspaceID: string
-      workspaceType: string
-      workspaceName: string
-    }
-
-type WorkspaceSelectValue = WorkspaceSelection | { type: "existing-list" }
-type ExistingWorkspaceSelectValue = { workspace: Workspace }
-
-async function loadWorkspaceAdaptors(input: {
-  sdk: ReturnType<typeof useSDK>
-  sync: ReturnType<typeof useSync>
-  toast: ReturnType<typeof useToast>
-}) {
-  const dir = input.sync.path.directory || input.sdk.directory
-  const url = new URL("/experimental/workspace/adaptor", input.sdk.url)
-  if (dir) url.searchParams.set("directory", dir)
-  const res = await input.sdk
-    .fetch(url)
-    .then((x) => x.json() as Promise<Adaptor[]>)
-    .catch(() => undefined)
-  if (res) return res
-  input.toast.show({
-    message: "Failed to load workspace adaptors",
-    variant: "error",
+function scoped(sdk: ReturnType<typeof useSDK>, sync: ReturnType<typeof useSync>, workspaceID: string) {
+  return createOpencodeClient({
+    baseUrl: sdk.url,
+    fetch: sdk.fetch,
+    directory: sync.path.directory || sdk.directory,
+    experimental_workspaceID: workspaceID,
  })
 }

-export async function openWorkspaceSelect(input: {
+export async function openWorkspaceSession(input: {
  dialog: ReturnType<typeof useDialog>
+  route: ReturnType<typeof useRoute>
  sdk: ReturnType<typeof useSDK>
  sync: ReturnType<typeof useSync>
  toast: ReturnType<typeof useToast>
-  onSelect: (selection: WorkspaceSelection) => Promise<void> | void
+  workspaceID: string
 }) {
-  input.dialog.clear()
-  const adaptors = await loadWorkspaceAdaptors(input)
-  if (!adaptors) return
-  input.dialog.replace(() => <DialogWorkspaceSelect adaptors={adaptors} onSelect={input.onSelect} />)
+  const client = scoped(input.sdk, input.sync, input.workspaceID)
+
+  while (true) {
+    const result = await client.session.create({ workspace: input.workspaceID }).catch(() => undefined)
+    if (!result) {
+      input.toast.show({
+        message: "Failed to create workspace session",
+        variant: "error",
+      })
+      return
+    }
+    if (result.response?.status && result.response.status >= 500 && result.response.status < 600) {
+      await sleep(1000)
+      continue
+    }
+    if (!result.data) {
+      input.toast.show({
+        message: "Failed to create workspace session",
+        variant: "error",
+      })
+      return
+    }
+
+    input.route.navigate({
+      type: "session",
+      sessionID: result.data.id,
+    })
+    input.dialog.clear()
+    return
+  }
 }

-export async function warpWorkspaceSession(input: {
+export async function restoreWorkspaceSession(input: {
  dialog: ReturnType<typeof useDialog>
  sdk: ReturnType<typeof useSDK>
  sync: ReturnType<typeof useSync>
  project: ReturnType<typeof useProject>
  toast: ReturnType<typeof useToast>
-  workspaceID: string | null
+  workspaceID: string
  sessionID: string
  done?: () => void
-  showSuccessToast?: boolean
-}): Promise<boolean> {
-  const result = await (input.workspaceID === null
-    ? input.sdk.client.experimental.workspace.detach({
-        workspaceID: null,
-        sessionID: input.sessionID,
-      })
-    : input.sdk.client.experimental.workspace.warp({
-        id: input.workspaceID,
-        sessionID: input.sessionID,
-      })
-  ).catch(() => undefined)
-  if (!result || result.error) {
+}) {
+  const result = await input.sdk.client.experimental.workspace
+    .sessionRestore({ id: input.workspaceID, sessionID: input.sessionID })
+    .catch(() => undefined)
+  if (!result?.data) {
    input.toast.show({
-      message: `Failed to warp session: ${errorMessage(result?.error ?? "no response")}`,
+      message: `Failed to restore session: ${errorMessage(result?.error ?? "no response")}`,
      variant: "error",
    })
-    return false
+    return
  }

  input.project.workspace.set(input.workspaceID)

  await input.sync.bootstrap({ fatal: false }).catch(() => undefined)

-  await Promise.all([input.project.workspace.sync(), input.sync.session.refresh()])
+  await Promise.all([input.project.workspace.sync(), input.sync.session.sync(input.sessionID)])

-  if (input.showSuccessToast !== false) {
-    input.toast.show({
-      message: input.workspaceID === null ? "Session moved to the local project" : "Session warped into the new workspace",
-      variant: "success",
-    })
-  }
+  input.toast.show({
+    message: "Session restored into the new workspace",
+    variant: "success",
+  })
  input.done?.()
-  if (input.done) return true
+  if (input.done) return
  input.dialog.clear()
-  return true
 }

-export function DialogWorkspaceSelect(props: {
-  adaptors?: Adaptor[]
-  onSelect: (selection: WorkspaceSelection) => Promise<void> | void
-}) {
+export function DialogWorkspaceCreate(props: { onSelect: (workspaceID: string) => Promise<void> | void }) {
  const dialog = useDialog()
-  const project = useProject()
  const sync = useSync()
+  const project = useProject()
  const sdk = useSDK()
  const toast = useToast()
-  const [adaptors, setAdaptors] = createSignal<Adaptor[] | undefined>(props.adaptors)
+  const [creating, setCreating] = createSignal<string>()
+  const [adaptors, setAdaptors] = createSignal<Adaptor[]>()

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

-  const options = createMemo<DialogSelectOption<WorkspaceSelectValue>[]>(() => {
-    const list = adaptors()
-    if (!list) return []
-    const recent = sync.data.session
-      .toSorted((a, b) => b.time.updated - a.time.updated)
-      .flatMap((session) => (session.workspaceID ? [session.workspaceID] : []))
-      .filter((workspaceID, index, list) => list.indexOf(workspaceID) === index)
-      .slice(0, 3)
-      .flatMap((workspaceID) => {
-        const workspace = project.workspace.get(workspaceID)
-        return workspace ? [workspace] : []
-      })
-    return [
-      ...list.map((adaptor) => ({
-        title: adaptor.name,
-        value: { type: "new" as const, workspaceType: adaptor.type, workspaceName: adaptor.name },
-        description: adaptor.description,
-        category: "New workspace",
-      })),
-      {
-        title: "None",
-        value: { type: "none" as const },
-        description: "Use the local project",
-        category: "Choose workspace",
-      },
-      ...recent.map((workspace: Workspace) => ({
-        title: workspace.name,
-        description: `(${workspace.type})`,
-        value: {
-          type: "existing" as const,
-          workspaceID: workspace.id,
-          workspaceType: workspace.type,
-          workspaceName: workspace.name,
+  const options = createMemo(() => {
+    const type = creating()
+    if (type) {
+      return [
+        {
+          title: `Creating ${type} workspace...`,
+          value: "creating" as const,
+          description: "This can take a while for remote environments",
        },
-        category: "Choose workspace",
-      })),
-      {
-        title: "View all workspaces",
-        value: { type: "existing-list" as const },
-        description: "Choose from all workspaces",
-        category: "Choose workspace",
-      },
-    ]
+      ]
+    }
+    const list = adaptors()
+    if (!list) {
+      return [
+        {
+          title: "Loading workspaces...",
+          value: "loading" as const,
+          description: "Fetching available workspace adaptors",
+        },
+      ]
+    }
+    return list.map((item) => ({
+      title: item.name,
+      value: item.type,
+      description: item.description,
+    }))
  })

-  if (!adaptors()) return null
+  const create = async (type: string) => {
+    if (creating()) return
+    setCreating(type)
+
+    const result = await sdk.client.experimental.workspace.create({ type, branch: null }).catch(() => {
+      toast.show({
+        message: "Creating workspace failed",
+        variant: "error",
+      })
+      return undefined
+    })
+
+    const workspace = result?.data
+    if (!workspace) {
+      setCreating(undefined)
+      toast.show({
+        message: `Failed to create workspace: ${errorMessage(result?.error ?? "no response")}`,
+        variant: "error",
+      })
+      return
+    }
+
+    await project.workspace.sync()
+    await props.onSelect(workspace.id)
+    setCreating(undefined)
+  }
+
  return (
-    <DialogSelect<WorkspaceSelectValue>
-      title="Warp"
+    <DialogSelect
+      title={creating() ? "Creating Workspace" : "New Workspace"}
      skipFilter={true}
-      renderFilter={false}
      options={options()}
      onSelect={(option) => {
-        if (!option.value) return
-        if (option.value.type === "none") {
-          void props.onSelect(option.value)
-          return
-        }
-        if (option.value.type === "new") {
-          void props.onSelect(option.value)
-          return
-        }
-        if (option.value.type === "existing") {
-          void props.onSelect(option.value)
-          return
-        }
-
-        dialog.replace(() => <DialogExistingWorkspaceSelect onSelect={props.onSelect} />)
-      }}
-    />
-  )
-}
-
-function DialogExistingWorkspaceSelect(props: { onSelect: (selection: WorkspaceSelection) => Promise<void> | void }) {
-  const project = useProject()
-
-  const options = createMemo<DialogSelectOption<ExistingWorkspaceSelectValue>[]>(() =>
-    project.workspace
-      .list()
-      .filter((workspace) => project.workspace.status(workspace.id) === "connected")
-      .map((workspace: Workspace) => ({
-        title: workspace.name,
-        description: `(${workspace.type})`,
-        value: { workspace },
-      })),
-  )
-
-  return (
-    <DialogSelect<ExistingWorkspaceSelectValue>
-      title="Existing Workspace"
-      options={options()}
-      onSelect={(option) => {
-        void props.onSelect({
-          type: "existing",
-          workspaceID: option.value.workspace.id,
-          workspaceType: option.value.workspace.type,
-          workspaceName: option.value.workspace.name,
-        })
+        if (option.value === "creating" || option.value === "loading") return
+        void create(option.value)
      }}
    />
  )
@@ -7,7 +7,6 @@ import { Filesystem } from "@/util/filesystem"
 import { useLocal } from "@tui/context/local"
 import { tint, useTheme } from "@tui/context/theme"
 import { EmptyBorder, SplitBorder } from "@tui/component/border"
-import { Spinner } from "@tui/component/spinner"
 import { useSDK } from "@tui/context/sdk"
 import { useRoute } from "@tui/context/route"
 import { useProject } from "@tui/context/project"
@@ -41,16 +40,13 @@ import { useKV } from "../../context/kv"
 import { createFadeIn } from "../../util/signal"
 import { useTextareaKeybindings } from "../textarea-keybindings"
 import { DialogSkill } from "../dialog-skill"
-import { openWorkspaceSelect, warpWorkspaceSession, type WorkspaceSelection } from "../dialog-workspace-create"
+import { DialogWorkspaceCreate, restoreWorkspaceSession } from "../dialog-workspace-create"
 import { DialogWorkspaceUnavailable } from "../dialog-workspace-unavailable"
 import { useArgs } from "@tui/context/args"
-import { Flag } from "@opencode-ai/core/flag/flag"
-import { WorkspaceLabel, type WorkspaceStatus } from "../workspace-label"

 export type PromptProps = {
  sessionID?: string
  workspaceID?: string
-  onWorkspaceCreatingChange?: (creating: boolean) => void
  visible?: boolean
  disabled?: boolean
  onSubmit?: () => void
@@ -153,94 +149,9 @@ export function Prompt(props: PromptProps) {
  })
  let lastSubmittedEditorSelectionKey: string | undefined
  const [auto, setAuto] = createSignal<AutocompleteRef>()
-  const [workspaceSelection, setWorkspaceSelection] = createSignal<WorkspaceSelection>()
-  const [workspaceCreating, setWorkspaceCreating] = createSignal(false)
-  const [workspaceCreatingDots, setWorkspaceCreatingDots] = createSignal(3)
-  const [warpNotice, setWarpNotice] = createSignal<string>()
  const currentProviderLabel = createMemo(() => local.model.parsed().provider)
  const hasRightContent = createMemo(() => Boolean(props.right))

-  function selectWorkspace(selection: WorkspaceSelection | undefined) {
-    setWorkspaceSelection(selection)
-  }
-
-  function setCreatingWorkspace(creating: boolean) {
-    setWorkspaceCreating(creating)
-    props.onWorkspaceCreatingChange?.(creating)
-  }
-
-  function showWarpNotice(name: string) {
-    setWarpNotice(`Warped to ${name}`)
-    setTimeout(() => setWarpNotice(undefined), 4000)
-  }
-
-  async function createWorkspace(selection: Extract<WorkspaceSelection, { type: "new" }>) {
-    setCreatingWorkspace(true)
-    const result = await sdk.client.experimental.workspace
-      .create({ type: selection.workspaceType, branch: null })
-      .catch(() => undefined)
-    if (result == undefined || result.error || !result.data) {
-      selectWorkspace(undefined)
-      setCreatingWorkspace(false)
-      toast.show({
-        message: "Creating workspace failed",
-        variant: "error",
-      })
-      return
-    }
-
-    await project.workspace.sync()
-    const workspace = result.data
-    selectWorkspace({
-      type: "existing",
-      workspaceID: workspace.id,
-      workspaceType: workspace.type,
-      workspaceName: workspace.name,
-    })
-    setCreatingWorkspace(false)
-    return workspace
-  }
-
-  async function warpSession(selection: WorkspaceSelection) {
-    if (!props.sessionID) {
-      selectWorkspace(selection)
-      dialog.clear()
-      if (selection.type === "new") void createWorkspace(selection)
-      return
-    }
-    selectWorkspace(selection)
-    dialog.clear()
-
-    const workspace =
-      selection.type === "none"
-        ? { id: null, name: "local project" }
-        : selection.type === "existing"
-        ? { id: selection.workspaceID, name: selection.workspaceName }
-        : await createWorkspace(selection)
-    if (!workspace) return
-
-    const warped = await warpWorkspaceSession({
-      dialog,
-      sdk,
-      sync,
-      project,
-      toast,
-      workspaceID: workspace.id,
-      sessionID: props.sessionID,
-      showSuccessToast: false,
-    })
-    if (warped) showWarpNotice(workspace.name)
-  }
-
-  createEffect(() => {
-    if (!workspaceCreating()) {
-      setWorkspaceCreatingDots(3)
-      return
-    }
-    const timer = setInterval(() => setWorkspaceCreatingDots((dots) => (dots % 3) + 1), 1000)
-    onCleanup(() => clearInterval(timer))
-  })
-
  function promptModelWarning() {
    toast.show({
      variant: "warning",
@@ -273,7 +184,6 @@ export function Prompt(props: PromptProps) {
  })

  createEffect(() => {
-    if (!input || input.isDestroyed) return
    if (props.disabled) input.cursorColor = theme.backgroundElement
    if (!props.disabled) input.cursorColor = theme.text
  })
@@ -540,27 +450,6 @@ export function Prompt(props: PromptProps) {
          ))
        },
      },
-      {
-        title: "Warp",
-        description: "Change the workspace for the session",
-        value: "workspace.set",
-        category: "Session",
-        enabled: Flag.OPENCODE_EXPERIMENTAL_WORKSPACES,
-        slash: {
-          name: "warp",
-        },
-        onSelect: (dialog) => {
-          void openWorkspaceSelect({
-            dialog,
-            sdk,
-            sync,
-            toast,
-            onSelect: (selection) => {
-              void warpSession(selection)
-            },
-          })
-        },
-      },
    ]
  })

@@ -644,7 +533,7 @@ export function Prompt(props: PromptProps) {
  })

  function restoreExtmarksFromParts(parts: PromptInfo["parts"]) {
-    if (!input.isDestroyed) input.extmarks.clear()
+    input.extmarks.clear()
    setStore("extmarkToPartIndex", new Map())

    parts.forEach((part, partIndex) => {
@@ -777,8 +666,6 @@ export function Prompt(props: PromptProps) {
  ])

  async function submit() {
-    setWarpNotice(undefined)
-
    // IME: double-defer may fire before onContentChange flushes the last
    // composed character (e.g. Korean hangul) to the store, so read
    // plainText directly and sync before any downstream reads.
@@ -787,7 +674,6 @@ export function Prompt(props: PromptProps) {
      syncExtmarksWithPromptParts()
    }
    if (props.disabled) return false
-    if (workspaceCreating()) return false
    if (autocomplete?.visible) return false
    if (!store.prompt.input) return false
    const agent = local.agent.current()
@@ -810,22 +696,45 @@ export function Prompt(props: PromptProps) {
      dialog.replace(() => (
        <DialogWorkspaceUnavailable
          onRestore={() => {
-            void openWorkspaceSelect({
-              dialog,
-              sdk,
-              sync,
-              toast,
-              onSelect: (selection) => {
-                void warpSession(selection)
-              },
-            })
-            return false
+            dialog.replace(() => (
+              <DialogWorkspaceCreate
+                onSelect={(nextWorkspaceID) =>
+                  restoreWorkspaceSession({
+                    dialog,
+                    sdk,
+                    sync,
+                    project,
+                    toast,
+                    workspaceID: nextWorkspaceID,
+                    sessionID: props.sessionID!,
+                  })
+                }
+              />
+            ))
          }}
        />
      ))
      return false
    }

+    let sessionID = props.sessionID
+    if (sessionID == null) {
+      const res = await sdk.client.session.create({ workspace: props.workspaceID })
+
+      if (res.error) {
+        console.log("Creating a session failed:", res.error)
+
+        toast.show({
+          message: "Creating a session failed. Open console for more details.",
+          variant: "error",
+        })
+
+        return true
+      }
+
+      sessionID = res.data.id
+    }
+
    const messageID = MessageID.ascending()
    let inputText = store.prompt.input

@@ -850,7 +759,6 @@ export function Prompt(props: PromptProps) {

    // Capture mode before it gets reset
    const currentMode = store.mode
-    const submittedPrompt = unwrap(store.prompt)
    const variant = local.model.variant.current()
    const editorSelection = fileContextEnabled() ? editor.selection() : undefined
    const editorSelectionKey = editorSelection ? getEditorSelectionKey(editorSelection) : undefined
@@ -886,33 +794,6 @@ export function Prompt(props: PromptProps) {
          ]
        : []

-    let sessionID = props.sessionID
-    if (sessionID == null) {
-      const workspace = workspaceSelection()
-      const workspaceID = iife(() => {
-        if (!workspace) return undefined
-        if (workspace.type === "none") return undefined
-        if (workspace.type === "existing") return workspace.workspaceID
-        return undefined
-      })
-
-      const res = await sdk.client.session.create({ workspace: workspaceID })
-
-      if (res.error) {
-        setCreatingWorkspace(false)
-        console.log("Creating a session failed:", res.error)
-
-        toast.show({
-          message: "Creating a session failed. Open console for more details.",
-          variant: "error",
-        })
-
-        return true
-      }
-
-      sessionID = res.data.id
-    }
-
    if (store.mode === "shell") {
      void sdk.client.session.shell({
        sessionID,
@@ -977,7 +858,7 @@ export function Prompt(props: PromptProps) {
      lastSubmittedEditorSelectionKey = editorSelectionKey
    }
    history.append({
-      ...submittedPrompt,
+      ...store.prompt,
      mode: currentMode,
    })
    input.extmarks.clear()
@@ -996,7 +877,7 @@ export function Prompt(props: PromptProps) {
          sessionID,
        })
      }, 50)
-    if (!input.isDestroyed) input.clear()
+    input.clear()
    return true
  }
  const exit = useExit()
@@ -1117,29 +998,6 @@ export function Prompt(props: PromptProps) {
    return `Ask anything... "${list()[store.placeholder % list().length]}"`
  })

-  const workspaceLabel = createMemo<
-    | { type: "new"; workspaceType: string }
-    | { type: "existing"; workspaceType: string; workspaceName: string; status?: WorkspaceStatus }
-    | undefined
-  >(() => {
-    const selected = workspaceSelection()
-    if (!selected) return
-    if (selected.type === "none") return
-    if (props.sessionID && !workspaceCreating()) return
-    if (selected.type === "new") {
-      return {
-        type: "new",
-        workspaceType: selected.workspaceType,
-      }
-    }
-    return {
-      type: "existing",
-      workspaceType: selected.workspaceType,
-      workspaceName: selected.workspaceName,
-      status: selected.type === "existing" ? "connected" : undefined,
-    }
-  })
-
  const spinnerDef = createMemo(() => {
    const agent = local.agent.current()
    const color = agent ? local.agent.color(agent.name) : theme.border
@@ -1396,7 +1254,7 @@ export function Prompt(props: PromptProps) {
              }}
              onMouseDown={(r: MouseEvent) => r.target?.focus()}
              focusedBackgroundColor={theme.backgroundElement}
-              cursorColor={props.disabled ? theme.backgroundElement : theme.text}
+              cursorColor={theme.text}
              syntaxStyle={syntax()}
            />
            <box flexDirection="row" flexShrink={0} paddingTop={1} gap={1} justifyContent="space-between">
@@ -1466,124 +1324,86 @@ export function Prompt(props: PromptProps) {
          />
        </box>
        <box width="100%" flexDirection="row" justifyContent="space-between">
-          <Switch>
-            <Match when={status().type !== "idle"}>
-              <box
-                flexDirection="row"
-                gap={1}
-                flexGrow={1}
-                justifyContent={status().type === "retry" ? "space-between" : "flex-start"}
-              >
-                <box flexShrink={0} flexDirection="row" gap={1}>
-                  <box marginLeft={1}>
-                    <Show when={kv.get("animations_enabled", true)} fallback={<text fg={theme.textMuted}>[⋯]</text>}>
-                      <spinner color={spinnerDef().color} frames={spinnerDef().frames} interval={40} />
-                    </Show>
-                  </box>
-                  <box flexDirection="row" gap={1} flexShrink={0}>
-                    {(() => {
-                      const retry = createMemo(() => {
-                        const s = status()
-                        if (s.type !== "retry") return
-                        return s
-                      })
-                      const message = createMemo(() => {
-                        const r = retry()
-                        if (!r) return
-                        if (r.message.includes("exceeded your current quota") && r.message.includes("gemini"))
-                          return "gemini is way too hot right now"
-                        if (r.message.length > 80) return r.message.slice(0, 80) + "..."
-                        return r.message
-                      })
-                      const isTruncated = createMemo(() => {
-                        const r = retry()
-                        if (!r) return false
-                        return r.message.length > 120
-                      })
-                      const [seconds, setSeconds] = createSignal(0)
-                      onMount(() => {
-                        const timer = setInterval(() => {
-                          const next = retry()?.next
-                          if (next) setSeconds(Math.round((next - Date.now()) / 1000))
-                        }, 1000)
-
-                        onCleanup(() => {
-                          clearInterval(timer)
-                        })
-                      })
-                      const handleMessageClick = () => {
-                        const r = retry()
-                        if (!r) return
-                        if (isTruncated()) {
-                          void DialogAlert.show(dialog, "Retry Error", r.message)
-                        }
-                      }
-
-                      const retryText = () => {
-                        const r = retry()
-                        if (!r) return ""
-                        const baseMessage = message()
-                        const truncatedHint = isTruncated() ? " (click to expand)" : ""
-                        const duration = formatDuration(seconds())
-                        const retryInfo = ` [retrying ${duration ? `in ${duration} ` : ""}attempt #${r.attempt}]`
-                        return baseMessage + truncatedHint + retryInfo
-                      }
-
-                      return (
-                        <Show when={retry()}>
-                          <box onMouseUp={handleMessageClick}>
-                            <text fg={theme.error}>{retryText()}</text>
-                          </box>
-                        </Show>
-                      )
-                    })()}
-                  </box>
-                </box>
-                <text fg={store.interrupt > 0 ? theme.primary : theme.text}>
-                  esc{" "}
-                  <span style={{ fg: store.interrupt > 0 ? theme.primary : theme.textMuted }}>
-                    {store.interrupt > 0 ? "again to interrupt" : "interrupt"}
-                  </span>
-                </text>
-              </box>
-            </Match>
-            <Match when={warpNotice()}>
-              {(notice) => (
-                <box paddingLeft={3}>
-                  <text fg={theme.accent}>{notice()}</text>
-                </box>
-              )}
-            </Match>
-            <Match when={workspaceLabel()}>
-              {(workspace) => (
-                <box paddingLeft={3} flexDirection="row" gap={1}>
-                  <Show when={workspaceCreating()}>
-                    <Spinner color={theme.accent} />
+          <Show when={status().type !== "idle"} fallback={props.hint ?? <text />}>
+            <box
+              flexDirection="row"
+              gap={1}
+              flexGrow={1}
+              justifyContent={status().type === "retry" ? "space-between" : "flex-start"}
+            >
+              <box flexShrink={0} flexDirection="row" gap={1}>
+                <box marginLeft={1}>
+                  <Show when={kv.get("animations_enabled", true)} fallback={<text fg={theme.textMuted}>[⋯]</text>}>
+                    <spinner color={spinnerDef().color} frames={spinnerDef().frames} interval={40} />
                  </Show>
-                  <text fg={workspaceCreating() ? theme.accent : theme.text}>
-                    {(() => {
-                      const item = workspace()
-                      if (item.type === "new") {
-                        if (workspaceCreating())
-                          return `Creating ${item.workspaceType}${".".repeat(workspaceCreatingDots())}`
-                        return (
-                          <>
-                            Workspace <span style={{ fg: theme.textMuted }}>(new {item.workspaceType})</span>
-                          </>
-                        )
-                      }
-                      return (
-                        <>
-                          Workspace <span style={{ fg: theme.textMuted }}>{item.workspaceName}</span>
-                        </>
-                      )
-                    })()}
-                  </text>
                </box>
-              )}
-            </Match>
-            <Match when={true}>{props.hint ?? <text />}</Match>
-          </Switch>
+                <box flexDirection="row" gap={1} flexShrink={0}>
+                  {(() => {
+                    const retry = createMemo(() => {
+                      const s = status()
+                      if (s.type !== "retry") return
+                      return s
+                    })
+                    const message = createMemo(() => {
+                      const r = retry()
+                      if (!r) return
+                      if (r.message.includes("exceeded your current quota") && r.message.includes("gemini"))
+                        return "gemini is way too hot right now"
+                      if (r.message.length > 80) return r.message.slice(0, 80) + "..."
+                      return r.message
+                    })
+                    const isTruncated = createMemo(() => {
+                      const r = retry()
+                      if (!r) return false
+                      return r.message.length > 120
+                    })
+                    const [seconds, setSeconds] = createSignal(0)
+                    onMount(() => {
+                      const timer = setInterval(() => {
+                        const next = retry()?.next
+                        if (next) setSeconds(Math.round((next - Date.now()) / 1000))
+                      }, 1000)
+
+                      onCleanup(() => {
+                        clearInterval(timer)
+                      })
+                    })
+                    const handleMessageClick = () => {
+                      const r = retry()
+                      if (!r) return
+                      if (isTruncated()) {
+                        void DialogAlert.show(dialog, "Retry Error", r.message)
+                      }
+                    }
+
+                    const retryText = () => {
+                      const r = retry()
+                      if (!r) return ""
+                      const baseMessage = message()
+                      const truncatedHint = isTruncated() ? " (click to expand)" : ""
+                      const duration = formatDuration(seconds())
+                      const retryInfo = ` [retrying ${duration ? `in ${duration} ` : ""}attempt #${r.attempt}]`
+                      return baseMessage + truncatedHint + retryInfo
+                    }
+
+                    return (
+                      <Show when={retry()}>
+                        <box onMouseUp={handleMessageClick}>
+                          <text fg={theme.error}>{retryText()}</text>
+                        </box>
+                      </Show>
+                    )
+                  })()}
+                </box>
+              </box>
+              <text fg={store.interrupt > 0 ? theme.primary : theme.text}>
+                esc{" "}
+                <span style={{ fg: store.interrupt > 0 ? theme.primary : theme.textMuted }}>
+                  {store.interrupt > 0 ? "again to interrupt" : "interrupt"}
+                </span>
+              </text>
+            </box>
+          </Show>
          <Show when={status().type !== "retry"}>
            <box gap={2} flexDirection="row">
              <Show when={editorFileLabelDisplay()}>{(file) => <text fg={theme.secondary}>{file()}</text>}</Show>
@@ -1,19 +0,0 @@
-import { useTheme } from "@tui/context/theme"
-
-export type WorkspaceStatus = "connected" | "connecting" | "disconnected" | "error"
-
-export function WorkspaceLabel(props: { type: string; name: string; status?: WorkspaceStatus; icon?: boolean }) {
-  const { theme } = useTheme()
-  const color = () => {
-    if (props.status === "connected") return theme.success
-    if (props.status === "error") return theme.error
-    return theme.textMuted
-  }
-
-  return (
-    <>
-      {props.icon ? <span style={{ fg: color() }}>● </span> : undefined}
-      <span style={{ fg: theme.text }}>{props.name}</span> <span style={{ fg: theme.textMuted }}>({props.type})</span>
-    </>
-  )
-}
@@ -12,22 +12,7 @@ export function useEvent() {
        return
      }

-      // Special hack for truly global events
-      if (event.directory === "global") {
-        handler(event.payload)
-      }
-
-      if (project.workspace.current()) {
-        if (event.workspace === project.workspace.current()) {
-          handler(event.payload)
-        }
-
-        return
-      }
-
-      if (event.directory === project.instance.directory()) {
-        handler(event.payload)
-      }
+      handler(event.payload)
    })
  }

@@ -7,7 +7,6 @@ import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/inst
 import { TuiPluginRuntime } from "@/cli/cmd/tui/plugin/runtime"

 import { getScrollAcceleration } from "../../util/scroll"
-import { WorkspaceLabel } from "../../component/workspace-label"

 export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
  const project = useProject()
@@ -15,10 +14,17 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
  const { theme } = useTheme()
  const tuiConfig = useTuiConfig()
  const session = createMemo(() => sync.session.get(props.sessionID))
-  const workspace = () => {
+  const workspaceStatus = () => {
    const workspaceID = session()?.workspaceID
-    if (!workspaceID) return
-    return project.workspace.get(workspaceID)
+    if (!workspaceID) return "error"
+    return project.workspace.status(workspaceID) ?? "error"
+  }
+  const workspaceLabel = () => {
+    const workspaceID = session()?.workspaceID
+    if (!workspaceID) return "unknown"
+    const info = project.workspace.get(workspaceID)
+    if (!info) return "unknown"
+    return `${info.type}: ${info.name}`
  }
  const scrollAcceleration = createMemo(() => getScrollAcceleration(tuiConfig))

@@ -61,19 +67,8 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
                </Show>
                <Show when={session()!.workspaceID}>
                  <text fg={theme.textMuted}>
-                    <Show
-                      when={workspace()}
-                      fallback={<WorkspaceLabel type="unknown" name={session()!.workspaceID!} status="error" icon />}
-                    >
-                      {(item) => (
-                        <WorkspaceLabel
-                          type={item().type}
-                          name={item().name}
-                          status={project.workspace.status(item().id) ?? "error"}
-                          icon
-                        />
-                      )}
-                    </Show>
+                    <span style={{ fg: workspaceStatus() === "connected" ? theme.success : theme.error }}>●</span>{" "}
+                    {workspaceLabel()}
                  </text>
                </Show>
                <Show when={session()!.share?.url}>
@@ -23,7 +23,6 @@ export interface DialogSelectProps<T> {
  onFilter?: (query: string) => void
  onSelect?: (option: DialogSelectOption<T>) => void
  skipFilter?: boolean
-  renderFilter?: boolean
  keybind?: {
    keybind?: Keybind.Info
    title: string
@@ -82,7 +81,7 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
  let input: InputRenderable

  const filtered = createMemo(() => {
-    if (props.skipFilter || props.renderFilter === false) return props.options.filter((x) => x.disabled !== true)
+    if (props.skipFilter) return props.options.filter((x) => x.disabled !== true)
    const needle = store.filter.toLowerCase()
    const options = pipe(
      props.options,
@@ -251,32 +250,30 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
            esc
          </text>
        </box>
-        <Show when={props.renderFilter !== false}>
-          <box paddingTop={1}>
-            <input
-              onInput={(e) => {
-                batch(() => {
-                  setStore("filter", e)
-                  props.onFilter?.(e)
-                })
-              }}
-              focusedBackgroundColor={theme.backgroundPanel}
-              cursorColor={theme.primary}
-              focusedTextColor={theme.textMuted}
-              ref={(r) => {
-                input = r
-                input.traits = { status: "FILTER" }
-                setTimeout(() => {
-                  if (!input) return
-                  if (input.isDestroyed) return
-                  input.focus()
-                }, 1)
-              }}
-              placeholder={props.placeholder ?? "Search"}
-              placeholderColor={theme.textMuted}
-            />
-          </box>
-        </Show>
+        <box paddingTop={1}>
+          <input
+            onInput={(e) => {
+              batch(() => {
+                setStore("filter", e)
+                props.onFilter?.(e)
+              })
+            }}
+            focusedBackgroundColor={theme.backgroundPanel}
+            cursorColor={theme.primary}
+            focusedTextColor={theme.textMuted}
+            ref={(r) => {
+              input = r
+              input.traits = { status: "FILTER" }
+              setTimeout(() => {
+                if (!input) return
+                if (input.isDestroyed) return
+                input.focus()
+              }, 1)
+            }}
+            placeholder={props.placeholder ?? "Search"}
+            placeholderColor={theme.textMuted}
+          />
+        </box>
      </box>
      <Show
        when={grouped().length > 0}
@@ -1,26 +1,27 @@
+import { lazy } from "@/util/lazy"
 import type { ProjectID } from "@/project/schema"
 import type { WorkspaceAdaptor, WorkspaceAdaptorEntry } from "../types"
-import { WorktreeAdaptor } from "./worktree"

-const BUILTIN: Record<string, WorkspaceAdaptor> = {
-  worktree: WorktreeAdaptor,
+const BUILTIN: Record<string, () => Promise<WorkspaceAdaptor>> = {
+  worktree: lazy(async () => (await import("./worktree")).WorktreeAdaptor),
 }

 const state = new Map<ProjectID, Map<string, WorkspaceAdaptor>>()

-export function getAdaptor(projectID: ProjectID, type: string): WorkspaceAdaptor {
+export async function getAdaptor(projectID: ProjectID, type: string): Promise<WorkspaceAdaptor> {
  const custom = state.get(projectID)?.get(type)
  if (custom) return custom

  const builtin = BUILTIN[type]
-  if (builtin) return builtin
+  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]) => {
+    Object.entries(BUILTIN).map(async ([type, init]) => {
+      const adaptor = await init()
      return {
        type,
        name: adaptor.name,
@@ -1,4 +1,6 @@
 import { Schema } from "effect"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Worktree } from "@/worktree"
 import { type WorkspaceAdaptor, WorkspaceInfo } from "../types"

 const WorktreeConfig = Schema.Struct({
@@ -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 = {
  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,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()
+  }
+}
@@ -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,7 +41,6 @@ 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"
@@ -91,7 +90,6 @@ export const AppLayer = Layer.mergeAll(
  Format.defaultLayer,
  Project.defaultLayer,
  Vcs.defaultLayer,
-  Workspace.defaultLayer,
  Worktree.defaultLayer,
  Pty.defaultLayer,
  Installation.defaultLayer,
@@ -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
-}
@@ -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,16 @@ 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.startsWith("oc://renderer")) 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
    },
  })
 }
@@ -8,6 +8,10 @@ import { zodObject } from "@/util/effect-zod"
 import { Instance } from "@/project/instance"
 import { errors } from "../../error"
 import { lazy } from "@/util/lazy"
+import * as Log from "@opencode-ai/core/util/log"
+import { errorData } from "@/util/error"
+
+const log = Log.create({ service: "server.workspace" })

 export const WorkspaceRoutes = lazy(() =>
  new Hono()
@@ -138,47 +142,56 @@ export const WorkspaceRoutes = lazy(() =>
      },
    )
    .post(
-      "/warp",
+      "/:id/session-restore",
      describeRoute({
-        summary: "Warp session into workspace",
-        description: "Move a session's sync history into the target workspace, or detach it to the local project.",
-        operationId: "experimental.workspace.detach",
+        summary: "Restore session into workspace",
+        description: "Replay a session's sync events into the target workspace in batches.",
+        operationId: "experimental.workspace.sessionRestore",
        responses: {
-          204: {
-            description: "Session warped",
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Workspace.SessionWarpInput.zodObject),
-      async (c) => {
-        await Workspace.sessionWarp(c.req.valid("json") as Workspace.SessionWarpInput)
-        return c.body(null, 204)
-      },
-    )
-    .post(
-      "/:id/warp",
-      describeRoute({
-        summary: "Warp session into workspace",
-        description: "Move a session's sync history into the target workspace.",
-        operationId: "experimental.workspace.warp",
-        responses: {
-          204: {
-            description: "Session warped",
+          200: {
+            description: "Session replay started",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z.object({
+                    total: z.number().int().min(0),
+                  }),
+                ),
+              },
+            },
          },
          ...errors(400),
        },
      }),
      validator("param", z.object({ id: zodObject(Workspace.Info).shape.id })),
-      validator("json", Workspace.SessionWarpInput.zodObject.omit({ workspaceID: true })),
+      validator("json", Workspace.SessionRestoreInput.zodObject.omit({ workspaceID: true })),
      async (c) => {
        const { id } = c.req.valid("param")
-        const body = c.req.valid("json") as Omit<Workspace.SessionWarpInput, "workspaceID">
-        await Workspace.sessionWarp({
+        const body = c.req.valid("json") as Omit<Workspace.SessionRestoreInput, "workspaceID">
+        log.info("session restore route requested", {
          workspaceID: id,
-          ...body,
+          sessionID: body.sessionID,
+          directory: Instance.directory,
        })
-        return c.body(null, 204)
+        try {
+          const result = await Workspace.sessionRestore({
+            workspaceID: id,
+            ...body,
+          })
+          log.info("session restore route complete", {
+            workspaceID: id,
+            sessionID: body.sessionID,
+            total: result.total,
+          })
+          return c.json(result)
+        } catch (err) {
+          log.error("session restore route failed", {
+            workspaceID: id,
+            sessionID: body.sessionID,
+            error: errorData(err),
+          })
+          throw err
+        }
      },
    ),
 )
@@ -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,4 @@
 import { NonNegativeInt } from "@/util/schema"
-import { SessionID } from "@/session/schema"
 import { Schema } from "effect"
 import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "../middleware/authorization"
@@ -22,9 +21,6 @@ export const ReplayPayload = Schema.Struct({
 export const ReplayResponse = Schema.Struct({
  sessionID: Schema.String,
 })
-export const SessionPayload = Schema.Struct({
-  sessionID: SessionID,
-})
 export const HistoryPayload = Schema.Record(Schema.String, NonNegativeInt)
 export const HistoryEvent = Schema.Struct({
  id: Schema.String,
@@ -37,7 +33,6 @@ export const HistoryEvent = Schema.Struct({
 export const SyncPaths = {
  start: `${root}/start`,
  replay: `${root}/replay`,
-  steal: `${root}/steal`,
  history: `${root}/history`,
 } as const

@@ -65,17 +60,6 @@ export const SyncApi = HttpApi.make("sync")
            description: "Validate and replay a complete sync event history.",
          }),
        ),
-        HttpApiEndpoint.post("steal", SyncPaths.steal, {
-          payload: SessionPayload,
-          success: described(SessionPayload, "Session stolen into workspace"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "sync.steal",
-            summary: "Steal session into workspace",
-            description: "Update a session to belong to the current workspace through the sync event system.",
-          }),
-        ),
        HttpApiEndpoint.post("history", SyncPaths.history, {
          payload: HistoryPayload,
          success: described(Schema.Array(HistoryEvent), "Sync events"),
@@ -1,7 +1,8 @@
 import { Workspace } from "@/control-plane/workspace"
 import { WorkspaceAdaptorEntry } from "@/control-plane/types"
+import { NonNegativeInt } from "@/util/schema"
 import { Schema, Struct } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { Authorization } from "../middleware/authorization"
 import { InstanceContextMiddleware } from "../middleware/instance-context"
 import { WorkspaceRoutingMiddleware } from "../middleware/workspace-routing"
@@ -9,15 +10,17 @@ import { described } from "./metadata"

 const root = "/experimental/workspace"
 export const CreatePayload = Schema.Struct(Struct.omit(Workspace.CreateInput.fields, ["projectID"]))
-export const WarpPayload = Schema.Struct(Struct.omit(Workspace.SessionWarpInput.fields, ["workspaceID"]))
+export const SessionRestorePayload = Schema.Struct(Struct.omit(Workspace.SessionRestoreInput.fields, ["workspaceID"]))
+export const SessionRestoreResponse = Schema.Struct({
+  total: NonNegativeInt,
+})

 export const WorkspacePaths = {
  adaptors: `${root}/adaptor`,
  list: root,
  status: `${root}/status`,
  remove: `${root}/:id`,
-  warpLocal: `${root}/warp`,
-  warp: `${root}/:id/warp`,
+  sessionRestore: `${root}/:id/session-restore`,
 } as const

 export const WorkspaceApi = HttpApi.make("workspace")
@@ -73,27 +76,16 @@ export const WorkspaceApi = HttpApi.make("workspace")
            description: "Remove an existing workspace.",
          }),
        ),
-        HttpApiEndpoint.post("warpLocal", WorkspacePaths.warpLocal, {
-          payload: Workspace.SessionWarpInput,
-          success: described(HttpApiSchema.NoContent, "Session warped"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.detach",
-            summary: "Warp session into workspace",
-            description: "Move a session's sync history into the target workspace, or detach it to the local project.",
-          }),
-        ),
-        HttpApiEndpoint.post("warp", WorkspacePaths.warp, {
+        HttpApiEndpoint.post("sessionRestore", WorkspacePaths.sessionRestore, {
          params: { id: Workspace.Info.fields.id },
-          payload: WarpPayload,
-          success: described(HttpApiSchema.NoContent, "Session warped"),
+          payload: SessionRestorePayload,
+          success: described(SessionRestoreResponse, "Session replay started"),
          error: HttpApiError.BadRequest,
        }).annotateMerge(
          OpenApi.annotations({
-            identifier: "experimental.workspace.warp",
-            summary: "Warp session into workspace",
-            description: "Move a session's sync history into the target workspace.",
+            identifier: "experimental.workspace.sessionRestore",
+            summary: "Restore session into workspace",
+            description: "Replay a session's sync events into the target workspace in batches.",
          }),
        ),
      )
@@ -1,7 +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"
@@ -103,7 +102,9 @@ export const ptyConnectRoute = HttpRouter.add(
    if (!handler) return HttpServerResponse.empty()

    yield* socket
-      .runRaw((message) => handlePtyInput(handler, message))
+      .runRaw((message) => {
+        handler.onMessage(typeof message === "string" ? message : message.slice().buffer)
+      })
      .pipe(
        Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
        Effect.ensuring(
@@ -62,7 +62,7 @@ export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session",
      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,
@@ -1,8 +1,5 @@
 import { startWorkspaceSyncing } from "@/control-plane/workspace"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
 import * as InstanceState from "@/effect/instance-state"
-import { Instance } from "@/project/instance"
-import { Session } from "@/session/session"
 import { Database } from "@/storage/db"
 import { SyncEvent } from "@/sync"
 import { EventTable } from "@/sync/event.sql"
@@ -15,7 +12,7 @@ import { or } from "drizzle-orm"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../api"
-import { HistoryPayload, ReplayPayload, SessionPayload } from "../groups/sync"
+import { HistoryPayload, ReplayPayload } from "../groups/sync"

 export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handlers) =>
  Effect.gen(function* () {
@@ -36,29 +33,6 @@ export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handl
      return { sessionID: events[0].aggregateID }
    })

-    const steal = Effect.fn("SyncHttpApi.steal")(function* (ctx: { payload: typeof SessionPayload.Type }) {
-      const instance = yield* InstanceState.context
-      const workspaceID = yield* InstanceState.workspaceID
-      if (!workspaceID) throw new Error("Cannot steal session without workspace context")
-
-      yield* Effect.sync(() =>
-        WorkspaceContext.provide({
-          workspaceID,
-          fn: () =>
-            Instance.restore(instance, () =>
-              SyncEvent.run(Session.Event.Updated, {
-                sessionID: ctx.payload.sessionID,
-                info: {
-                  workspaceID,
-                },
-              }),
-            ),
-        }),
-      )
-
-      return { sessionID: ctx.payload.sessionID }
-    })
-
    const history = Effect.fn("SyncHttpApi.history")(function* (ctx: { payload: typeof HistoryPayload.Type }) {
      const exclude = Object.entries(ctx.payload)
      return Database.use((db) =>
@@ -75,6 +49,6 @@ export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handl
      )
    })

-    return handlers.handle("start", start).handle("replay", replay).handle("steal", steal).handle("history", history)
+    return handlers.handle("start", start).handle("replay", replay).handle("history", history)
  }),
 )
@@ -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
    })

@@ -3,9 +3,9 @@ import { Workspace } from "@/control-plane/workspace"
 import * as InstanceState from "@/effect/instance-state"
 import { Instance } from "@/project/instance"
 import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../api"
-import { CreatePayload, WarpPayload } from "../groups/workspace"
+import { CreatePayload, SessionRestorePayload } from "../groups/workspace"

 export const workspaceHandlers = HttpApiBuilder.group(InstanceHttpApi, "workspace", (handlers) =>
  Effect.gen(function* () {
@@ -40,28 +40,19 @@ export const workspaceHandlers = HttpApiBuilder.group(InstanceHttpApi, "workspac
      return yield* Effect.promise(() => Instance.restore(instance, () => Workspace.remove(ctx.params.id)))
    })

-    const warp = Effect.fn("WorkspaceHttpApi.warp")(function* (ctx: {
+    const sessionRestore = Effect.fn("WorkspaceHttpApi.sessionRestore")(function* (ctx: {
      params: { id: Workspace.Info["id"] }
-      payload: typeof WarpPayload.Type
+      payload: typeof SessionRestorePayload.Type
    }) {
      const instance = yield* InstanceState.context
-      yield* Effect.promise(() =>
+      return yield* Effect.promise(() =>
        Instance.restore(instance, () =>
-          Workspace.sessionWarp({
+          Workspace.sessionRestore({
            workspaceID: ctx.params.id,
-            ...ctx.payload,
+            sessionID: ctx.payload.sessionID,
          }),
        ),
      )
-      return HttpApiSchema.NoContent.make()
-    })
-
-    const warpLocal = Effect.fn("WorkspaceHttpApi.warpLocal")(function* (ctx: {
-      payload: typeof Workspace.SessionWarpInput.Type
-    }) {
-      const instance = yield* InstanceState.context
-      yield* Effect.promise(() => Instance.restore(instance, () => Workspace.sessionWarp(ctx.payload)))
-      return HttpApiSchema.NoContent.make()
    })

    return handlers
@@ -70,7 +61,6 @@ export const workspaceHandlers = HttpApiBuilder.group(InstanceHttpApi, "workspac
      .handle("create", create)
      .handle("status", status)
      .handle("remove", remove)
-      .handle("warpLocal", warpLocal)
-      .handle("warp", warp)
+      .handle("sessionRestore", sessionRestore)
  }),
 )
@@ -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
  })
@@ -89,7 +89,7 @@ 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))
+    const adaptor = yield* Effect.promise(() => getAdaptor(workspace.projectID, workspace.type))
    return yield* Effect.promise(() => Promise.resolve(adaptor.target(workspace)))
  })
 }
@@ -101,7 +101,7 @@ function proxyRemote(
  url: URL,
 ): Effect.Effect<HttpServerResponse.HttpServerResponse, never, Socket.WebSocketConstructor> {
  return Effect.gen(function* () {
-    const syncing = yield* Effect.sync(() => Workspace.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,
@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
 import * as Socket from "effect/unstable/socket/Socket"
 import { Account } from "@/account/account"
 import { Agent } from "@/agent/agent"
@@ -31,7 +31,6 @@ import { ToolRegistry } from "@/tool/registry"
 import { lazy } from "@/util/lazy"
 import { Vcs } from "@/project/vcs"
 import { Worktree } from "@/worktree"
-import { isAllowedCorsOrigin } from "@/server/cors"
 import { InstanceHttpApi, RootHttpApi } from "./api"
 import { ServerAuthConfig, authorizationLayer } from "./middleware/authorization"
 import { eventRoute } from "./event"
@@ -56,6 +55,7 @@ import { workspaceRouterMiddleware, workspaceRoutingLayer } from "./middleware/w
 import { disposeMiddleware } from "./lifecycle"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"
 import * as ServerBackend from "@/server/backend"
+import type { Predicate } from "effect/Predicate"

 export const context = Context.makeUnsafe<unknown>(new Map())

@@ -69,14 +69,6 @@ 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 instanceApiRoutes = HttpApiBuilder.layer(InstanceHttpApi).pipe(
  Layer.provide([
@@ -113,8 +105,24 @@ const instanceRoutes = Layer.mergeAll(rawInstanceRoutes, instanceApiRoutes).pipe
 )

 export const routes = Layer.mergeAll(rootApiRoutes, instanceRoutes).pipe(
+  Layer.provide(
+    HttpRouter.cors({
+      maxAge: 86_400,
+      allowedOrigins: ((input) => {
+        return (
+          !input ||
+          input.startsWith("http://localhost:") ||
+          input.startsWith("http://127.0.0.1:") ||
+          input.startsWith("oc://renderer") ||
+          input === "tauri://localhost" ||
+          input === "http://tauri.localhost" ||
+          input === "https://tauri.localhost" ||
+          /^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(input)
+        )
+      }) as Predicate<string> as any,
+    }),
+  ),
  Layer.provide([
-    cors,
    runtime,
    Account.defaultLayer,
    Agent.defaultLayer,
@@ -15,9 +15,6 @@ import * as Log from "@opencode-ai/core/util/log"
 import { startWorkspaceSyncing } from "@/control-plane/workspace"
 import { Instance } from "@/project/instance"
 import { errors } from "../../error"
-import { Session } from "@/session/session"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { SessionID } from "@/session/schema"

 const ReplayEvent = z.object({
  id: z.string(),
@@ -26,9 +23,6 @@ const ReplayEvent = z.object({
  type: z.string(),
  data: z.record(z.string(), z.unknown()),
 })
-const SessionPayload = z.object({
-  sessionID: SessionID.zod,
-})

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

@@ -111,47 +105,6 @@ export const SyncRoutes = lazy(() =>
        })
      },
    )
-    .post(
-      "/steal",
-      describeRoute({
-        summary: "Steal session into workspace",
-        description: "Update a session to belong to the current workspace through the sync event system.",
-        operationId: "sync.steal",
-        responses: {
-          200: {
-            description: "Session stolen into workspace",
-            content: {
-              "application/json": {
-                schema: resolver(SessionPayload),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", SessionPayload),
-      async (c) => {
-        const body = c.req.valid("json")
-        const workspaceID = WorkspaceContext.workspaceID
-        if (!workspaceID) throw new Error("Cannot steal session without workspace context")
-
-        SyncEvent.run(Session.Event.Updated, {
-          sessionID: body.sessionID,
-          info: {
-            workspaceID,
-          },
-        })
-
-        log.info("sync session stolen", {
-          sessionID: body.sessionID,
-          workspaceID,
-        })
-
-        return c.json({
-          sessionID: body.sessionID,
-        })
-      },
-    )
    .post(
      "/history",
      describeRoute({
@@ -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" },
 ]
@@ -49,14 +48,14 @@ export function workspaceProxyURL(target: string | URL, requestURL: URL) {
  return proxyURL
 }

-async function getSessionWorkspace(url: URL) {
+async function getSession(url: URL) {
  const id = getWorkspaceRouteSessionID(url)
  if (!id) return null

  const session = await AppRuntime.runPromise(
    Session.Service.use((svc) => svc.get(id)).pipe(Effect.withSpan("WorkspaceRouter.lookup")),
  ).catch(() => undefined)
-  return session?.workspaceID
+  return session
 }

 export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): MiddlewareHandler {
@@ -65,10 +64,20 @@ export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): Middleware
  return async (c, next) => {
    const url = new URL(c.req.url)

-    const sessionWorkspaceID = await getSessionWorkspace(url)
-    const workspaceID = sessionWorkspaceID || url.searchParams.get("workspace")
+    const session = await getSession(url)
+    const workspaceID = session?.workspaceID || url.searchParams.get("workspace")

    if (!workspaceID || url.pathname.startsWith("/console") || Flag.OPENCODE_WORKSPACE_ID) {
+      if (session) {
+        return Instance.provide({
+          directory: session.directory,
+          init: () => AppRuntime.runPromise(InstanceBootstrap),
+          async fn() {
+            return next()
+          },
+        })
+      }
+
      return next()
    }

@@ -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),
 )
@@ -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({
@@ -3,7 +3,6 @@ import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
 export const EventSequenceTable = sqliteTable("event_sequence", {
  aggregate_id: text().notNull().primaryKey(),
  seq: integer().notNull(),
-  owner_id: text(),
 })

 export const EventTable = sqliteTable("event", {
@@ -121,7 +121,7 @@ export function project<Def extends Definition>(
  return [def, func as ProjectorFunc]
 }

-function process<Def extends Definition>(def: Def, event: Event<Def>, options: { publish: boolean; ownerID?: string }) {
+function process<Def extends Definition>(def: Def, event: Event<Def>, options: { publish: boolean }) {
  if (projectors == null) {
    throw new Error("No projectors available. Call `SyncEvent.init` to install projectors")
  }
@@ -131,6 +131,8 @@ function process<Def extends Definition>(def: Def, event: Event<Def>, options: {
    throw new Error(`Projector not found for event: ${def.type}`)
  }

+  // idempotent: need to ignore any events already logged
+
  Database.transaction((tx) => {
    projector(tx, event.data)

@@ -139,7 +141,6 @@ function process<Def extends Definition>(def: Def, event: Event<Def>, options: {
        .values({
          aggregate_id: event.aggregateID,
          seq: event.seq,
-          owner_id: options?.ownerID,
        })
        .onConflictDoUpdate({
          target: EventSequenceTable.aggregate_id,
@@ -184,7 +185,7 @@ function process<Def extends Definition>(def: Def, event: Event<Def>, options: {
  })
 }

-export function replay(event: SerializedEvent, options?: { publish: boolean; ownerID?: string }) {
+export function replay(event: SerializedEvent, options?: { publish: boolean }) {
  const def = registry.get(event.type)
  if (!def) {
    throw new Error(`Unknown event type: ${event.type}`)
@@ -192,7 +193,7 @@ export function replay(event: SerializedEvent, options?: { publish: boolean; own

  const row = Database.use((db) =>
    db
-      .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
+      .select({ seq: EventSequenceTable.seq })
      .from(EventSequenceTable)
      .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
      .get(),
@@ -203,16 +204,12 @@ export function replay(event: SerializedEvent, options?: { publish: boolean; own
    return
  }

-  if (row?.ownerID && row.ownerID !== options?.ownerID) {
-    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, ownerID: options?.ownerID ?? row?.ownerID ?? undefined })
+  process(def, event, { publish: !!options?.publish })
 }

 export function replayAll(events: SerializedEvent[], options?: { publish: boolean }) {
@@ -277,16 +274,6 @@ export function remove(aggregateID: string) {
  })
 }

-export function claim(aggregateID: string, ownerID: string) {
-  Database.use((db) =>
-    db
-      .update(EventSequenceTable)
-      .set({ owner_id: ownerID })
-      .where(eq(EventSequenceTable.aggregate_id, aggregateID))
-      .run(),
-  )
-}
-
 export function payloads() {
  return registry
    .entries()
@@ -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,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))
-  })
 })
@@ -1,8 +1,7 @@
 import { NodeHttpServer, NodeServices } from "@effect/platform-node"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { GlobalBus } from "@/bus/global"
 import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { HttpClient, HttpClientRequest, HttpRouter, HttpServerResponse } from "effect/unstable/http"
 import * as Socket from "effect/unstable/socket/Socket"
 import { mkdir } from "node:fs/promises"
@@ -13,7 +12,6 @@ import { Workspace } from "../../src/control-plane/workspace"
 import { InstanceRef, WorkspaceRef } from "../../src/effect/instance-ref"
 import { Instance } from "../../src/project/instance"
 import { Project } from "../../src/project/project"
-import { disposeMiddleware, markInstanceForDisposal } from "../../src/server/routes/instance/httpapi/lifecycle"
 import { instanceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/instance-context"
 import { workspaceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
 import { resetDatabase } from "../fixture/db"
@@ -86,40 +84,6 @@ const serveProbe = (probePath: HttpRouter.PathInput = "/probe") =>
    Layer.build,
  )

-const waitDisposedEvent = Effect.promise(
-  () =>
-    new Promise<{ directory?: string; workspace?: string }>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        GlobalBus.off("event", onEvent)
-        reject(new Error("timed out waiting for instance disposal"))
-      }, 10_000)
-
-      function onEvent(event: { directory?: string; workspace?: string; payload: { type?: string } }) {
-        if (event.payload.type !== "server.instance.disposed") return
-        clearTimeout(timer)
-        GlobalBus.off("event", onEvent)
-        resolve({ directory: event.directory, workspace: event.workspace })
-      }
-
-      GlobalBus.on("event", onEvent)
-    }),
-)
-
-const serveDisposeProbe = () =>
-  HttpRouter.serve(
-    HttpRouter.add(
-      "POST",
-      "/dispose-probe",
-      Effect.gen(function* () {
-        const instance = yield* InstanceRef
-        if (!instance) return HttpServerResponse.empty({ status: 500 })
-        yield* markInstanceForDisposal(instance)
-        return yield* HttpServerResponse.json(true)
-      }),
-    ).pipe(Layer.provide(instanceContextTestLayer)),
-    { middleware: disposeMiddleware, disableListenLog: true, disableLogger: true },
-  ).pipe(Layer.build)
-
 describe("HttpApi instance context middleware", () => {
  it.live("provides instance context from the routed directory", () =>
    Effect.gen(function* () {
@@ -200,27 +164,4 @@ describe("HttpApi instance context middleware", () => {
      })
    }),
  )
-
-  it.live("preserves selected workspace id on instance disposal events", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const workspace = yield* createLocalWorkspace({
-        projectID: project.project.id,
-        type: "instance-context-dispose-event",
-        directory: workspaceDir,
-      })
-      yield* serveDisposeProbe()
-      const disposed = yield* waitDisposedEvent.pipe(Effect.forkScoped)
-
-      const response = yield* HttpClientRequest.post(`/dispose-probe?workspace=${workspace.id}`).pipe(
-        HttpClient.execute,
-      )
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toBe(true)
-      expect(yield* Fiber.join(disposed)).toEqual({ directory: workspaceDir, workspace: workspace.id })
-    }),
-  )
 })
@@ -1,138 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Flag } from "@opencode-ai/core/flag/flag"
-import { GlobalBus } from "@/bus/global"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import * as Log from "@opencode-ai/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-const original = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI
-
-function app() {
-  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
-  return Server.Default().app
-}
-
-async function waitDisposed(directory: string) {
-  return await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      GlobalBus.off("event", onEvent)
-      reject(new Error("timed out waiting for instance disposal"))
-    }, 10_000)
-
-    function onEvent(event: { directory?: string; payload: { type?: string } }) {
-      if (event.payload.type !== "server.instance.disposed" || event.directory !== directory) return
-      clearTimeout(timer)
-      GlobalBus.off("event", onEvent)
-      resolve()
-    }
-
-    GlobalBus.on("event", onEvent)
-  })
-}
-
-afterEach(async () => {
-  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = original
-  await Instance.disposeAll()
-  await resetDatabase()
-})
-
-describe("instance HttpApi", () => {
-  test("serves catalog read endpoints through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-
-    const [commands, agents, skills, lsp, formatter] = await Promise.all([
-      app().request(InstancePaths.command, { headers: { "x-opencode-directory": tmp.path } }),
-      app().request(InstancePaths.agent, { headers: { "x-opencode-directory": tmp.path } }),
-      app().request(InstancePaths.skill, { headers: { "x-opencode-directory": tmp.path } }),
-      app().request(InstancePaths.lsp, { headers: { "x-opencode-directory": tmp.path } }),
-      app().request(InstancePaths.formatter, { headers: { "x-opencode-directory": tmp.path } }),
-    ])
-
-    expect(commands.status).toBe(200)
-    expect(await commands.json()).toContainEqual(expect.objectContaining({ name: "init", source: "command" }))
-
-    expect(agents.status).toBe(200)
-    expect(await agents.json()).toContainEqual(expect.objectContaining({ name: "build", mode: "primary" }))
-
-    expect(skills.status).toBe(200)
-    expect(await skills.json()).toBeArray()
-
-    expect(lsp.status).toBe(200)
-    expect(await lsp.json()).toEqual([])
-
-    expect(formatter.status).toBe(200)
-    expect(await formatter.json()).toEqual([])
-  })
-
-  test("serves project git init through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-    const disposed = waitDisposed(tmp.path)
-
-    const response = await app().request("/project/git/init", {
-      method: "POST",
-      headers: { "x-opencode-directory": tmp.path },
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
-    await disposed
-
-    const current = await app().request("/project/current", { headers: { "x-opencode-directory": tmp.path } })
-    expect(current.status).toBe(200)
-    expect(await current.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
-  })
-
-  test("serves project update through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-
-    const current = await app().request("/project/current", { headers: { "x-opencode-directory": tmp.path } })
-    expect(current.status).toBe(200)
-    const project = (await current.json()) as { id: string }
-
-    const response = await app().request(`/project/${project.id}`, {
-      method: "PATCH",
-      headers: { "x-opencode-directory": tmp.path, "content-type": "application/json" },
-      body: JSON.stringify({ name: "patched-project", commands: { start: "bun dev" } }),
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchObject({
-      id: project.id,
-      name: "patched-project",
-      commands: { start: "bun dev" },
-    })
-
-    const list = await app().request("/project", { headers: { "x-opencode-directory": tmp.path } })
-    expect(list.status).toBe(200)
-    expect(await list.json()).toContainEqual(
-      expect.objectContaining({ id: project.id, name: "patched-project", commands: { start: "bun dev" } }),
-    )
-  })
-
-  test("serves instance dispose through Hono bridge", async () => {
-    await using tmp = await tmpdir()
-
-    const disposed = new Promise<string | undefined>((resolve) => {
-      const onEvent = (event: { directory?: string; payload: { type?: string } }) => {
-        if (event.payload.type !== "server.instance.disposed") return
-        GlobalBus.off("event", onEvent)
-        resolve(event.directory)
-      }
-      GlobalBus.on("event", onEvent)
-    })
-
-    const response = await app().request(InstancePaths.dispose, {
-      method: "POST",
-      headers: { "x-opencode-directory": tmp.path },
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toBe(true)
-    expect(await disposed).toBe(tmp.path)
-  })
-})
@@ -1,83 +1,164 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
+import { afterEach, describe, expect, test } from "bun:test"
+import path from "path"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { describe, expect } from "bun:test"
-import { Config, Effect, FileSystem, Layer, Path } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
+import { GlobalBus } from "@/bus/global"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
 import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
+import * as Log from "@opencode-ai/core/util/log"
 import { resetDatabase } from "../fixture/db"
-import { tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"

-// Flip the experimental HttpApi flag so backend selection telemetry on the
-// production routes reports the right backend, and reset the database around
-// the test so per-instance state does not leak between runs. resetDatabase()
-// already calls Instance.disposeAll(), so we don't repeat it.
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const originalHttpApi = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI
-    Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
-    yield* Effect.promise(() => resetDatabase())
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = originalHttpApi
-        await resetDatabase()
-      }),
-    )
-  }),
-)
+void Log.init({ print: false })

-// Mount the production HttpApi route tree on a real Node HTTP server bound to
-// 127.0.0.1:0 and a fetch-based HttpClient that prepends the server URL. This
-// keeps the test wired through the same route layer production uses, without
-// going through Server.Default()/Hono.
-const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
-  ExperimentalHttpApiServer.routes,
-  { disableListenLog: true, disableLogger: true },
-)
+const original = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI

-const httpApiServerLayer = servedRoutes.pipe(
-  Layer.provide(Socket.layerWebSocketConstructorGlobal),
-  Layer.provideMerge(NodeHttpServer.layerTest),
-  Layer.provideMerge(NodeServices.layer),
-)
+function app() {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
+  return Server.Default().app
+}

-const it = testEffect(Layer.mergeAll(testStateLayer, httpApiServerLayer))
+async function waitDisposed(directory: string) {
+  return await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      GlobalBus.off("event", onEvent)
+      reject(new Error("timed out waiting for instance disposal"))
+    }, 10_000)

-const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-opencode-directory", dir)
+    function onEvent(event: { directory?: string; payload: { type?: string } }) {
+      if (event.payload.type !== "server.instance.disposed" || event.directory !== directory) return
+      clearTimeout(timer)
+      GlobalBus.off("event", onEvent)
+      resolve()
+    }
+
+    GlobalBus.on("event", onEvent)
+  })
+}
+
+afterEach(async () => {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = original
+  await Instance.disposeAll()
+  await resetDatabase()
+})

 describe("instance HttpApi", () => {
-  it.live("serves path and VCS read endpoints", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const fs = yield* FileSystem.FileSystem
-      const path = yield* Path.Path
-      yield* fs.writeFileString(path.join(dir, "changed.txt"), "hello")
+  test("serves path and VCS read endpoints through Hono bridge", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Bun.write(path.join(tmp.path, "changed.txt"), "hello")

-      const [paths, vcs, diff] = yield* Effect.all(
-        [
-          HttpClientRequest.get(InstancePaths.path).pipe(directoryHeader(dir), HttpClient.execute),
-          HttpClientRequest.get(InstancePaths.vcs).pipe(directoryHeader(dir), HttpClient.execute),
-          HttpClientRequest.get(InstancePaths.vcsDiff).pipe(
-            HttpClientRequest.setUrlParam("mode", "git"),
-            directoryHeader(dir),
-            HttpClient.execute,
-          ),
-        ],
-        { concurrency: "unbounded" },
-      )
+    const vcsDiff = new URL(`http://localhost${InstancePaths.vcsDiff}`)
+    vcsDiff.searchParams.set("mode", "git")

-      expect(paths.status).toBe(200)
-      expect(yield* paths.json).toMatchObject({ directory: dir, worktree: dir })
+    const [paths, vcs, diff] = await Promise.all([
+      app().request(InstancePaths.path, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(InstancePaths.vcs, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(vcsDiff, { headers: { "x-opencode-directory": tmp.path } }),
+    ])

-      expect(vcs.status).toBe(200)
-      expect(yield* vcs.json).toMatchObject({ branch: expect.any(String) })
+    expect(paths.status).toBe(200)
+    expect(await paths.json()).toMatchObject({ directory: tmp.path, worktree: tmp.path })

-      expect(diff.status).toBe(200)
-      expect(yield* diff.json).toContainEqual(
-        expect.objectContaining({ file: "changed.txt", additions: 1, status: "added" }),
-      )
-    }),
-  )
+    expect(vcs.status).toBe(200)
+    expect(await vcs.json()).toMatchObject({ branch: expect.any(String) })
+
+    expect(diff.status).toBe(200)
+    expect(await diff.json()).toContainEqual(
+      expect.objectContaining({ file: "changed.txt", additions: 1, status: "added" }),
+    )
+  })
+
+  test("serves catalog read endpoints through Hono bridge", async () => {
+    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
+
+    const [commands, agents, skills, lsp, formatter] = await Promise.all([
+      app().request(InstancePaths.command, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(InstancePaths.agent, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(InstancePaths.skill, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(InstancePaths.lsp, { headers: { "x-opencode-directory": tmp.path } }),
+      app().request(InstancePaths.formatter, { headers: { "x-opencode-directory": tmp.path } }),
+    ])
+
+    expect(commands.status).toBe(200)
+    expect(await commands.json()).toContainEqual(expect.objectContaining({ name: "init", source: "command" }))
+
+    expect(agents.status).toBe(200)
+    expect(await agents.json()).toContainEqual(expect.objectContaining({ name: "build", mode: "primary" }))
+
+    expect(skills.status).toBe(200)
+    expect(await skills.json()).toBeArray()
+
+    expect(lsp.status).toBe(200)
+    expect(await lsp.json()).toEqual([])
+
+    expect(formatter.status).toBe(200)
+    expect(await formatter.json()).toEqual([])
+  })
+
+  test("serves project git init through Hono bridge", async () => {
+    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
+    const disposed = waitDisposed(tmp.path)
+
+    const response = await app().request("/project/git/init", {
+      method: "POST",
+      headers: { "x-opencode-directory": tmp.path },
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
+    await disposed
+
+    const current = await app().request("/project/current", { headers: { "x-opencode-directory": tmp.path } })
+    expect(current.status).toBe(200)
+    expect(await current.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
+  })
+
+  test("serves project update through Hono bridge", async () => {
+    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
+
+    const current = await app().request("/project/current", { headers: { "x-opencode-directory": tmp.path } })
+    expect(current.status).toBe(200)
+    const project = (await current.json()) as { id: string }
+
+    const response = await app().request(`/project/${project.id}`, {
+      method: "PATCH",
+      headers: { "x-opencode-directory": tmp.path, "content-type": "application/json" },
+      body: JSON.stringify({ name: "patched-project", commands: { start: "bun dev" } }),
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({
+      id: project.id,
+      name: "patched-project",
+      commands: { start: "bun dev" },
+    })
+
+    const list = await app().request("/project", { headers: { "x-opencode-directory": tmp.path } })
+    expect(list.status).toBe(200)
+    expect(await list.json()).toContainEqual(
+      expect.objectContaining({ id: project.id, name: "patched-project", commands: { start: "bun dev" } }),
+    )
+  })
+
+  test("serves instance dispose through Hono bridge", async () => {
+    await using tmp = await tmpdir()
+
+    const disposed = new Promise<string | undefined>((resolve) => {
+      const onEvent = (event: { directory?: string; payload: { type?: string } }) => {
+        if (event.payload.type !== "server.instance.disposed") return
+        GlobalBus.off("event", onEvent)
+        resolve(event.directory)
+      }
+      GlobalBus.on("event", onEvent)
+    })
+
+    const response = await app().request(InstancePaths.dispose, {
+      method: "POST",
+      headers: { "x-opencode-directory": tmp.path },
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toBe(true)
+    expect(await disposed).toBe(tmp.path)
+  })
 })
@@ -1,76 +0,0 @@
-import { NodeHttpServer } from "@effect/platform-node"
-import { Session } from "@/session/session"
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter } from "effect/unstable/http"
-import { HttpApi, HttpApiBuilder } from "effect/unstable/httpapi"
-import { McpApi, McpPaths } from "../../src/server/routes/instance/httpapi/groups/mcp"
-import { Authorization } from "../../src/server/routes/instance/httpapi/middleware/authorization"
-import { InstanceContextMiddleware } from "../../src/server/routes/instance/httpapi/middleware/instance-context"
-import {
-  WorkspaceRouteContext,
-  WorkspaceRoutingMiddleware,
-} from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
-import { testEffect } from "../lib/effect"
-
-const TestHttpApi = HttpApi.make("opencode-instance").addHttpApi(McpApi)
-const fakeSession = Layer.mock(Session.Service)({})
-const testMcpHandlers = HttpApiBuilder.group(TestHttpApi, "mcp", (handlers) =>
-  Effect.succeed(
-    handlers
-      .handle("status", () => Effect.die("unexpected MCP status"))
-      .handle("add", () => Effect.die("unexpected MCP add"))
-      .handle("authStart", () =>
-        Effect.succeed({ authorizationUrl: "https://auth.example/start", oauthState: "state-123" }),
-      )
-      .handle("authCallback", () => Effect.die("unexpected MCP authCallback"))
-      .handle("authAuthenticate", () => Effect.die("unexpected MCP authAuthenticate"))
-      .handle("authRemove", () => Effect.die("unexpected MCP authRemove"))
-      .handle("connect", () => Effect.die("unexpected MCP connect"))
-      .handle("disconnect", () => Effect.die("unexpected MCP disconnect")),
-  ),
-)
-
-const passthroughAuthorization = Layer.succeed(
-  Authorization,
-  Authorization.of({
-    basic: (effect) => effect,
-    authToken: (effect) => effect,
-  }),
-)
-
-const passthroughInstanceContext = Layer.succeed(
-  InstanceContextMiddleware,
-  InstanceContextMiddleware.of((effect) => effect),
-)
-
-const testWorkspaceRouting = Layer.succeed(
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingMiddleware.of((effect) =>
-    effect.pipe(Effect.provideService(WorkspaceRouteContext, WorkspaceRouteContext.of({ directory: process.cwd() }))),
-  ),
-)
-
-const it = testEffect(
-  HttpRouter.serve(
-    HttpApiBuilder.layer(TestHttpApi).pipe(
-      Layer.provide(testMcpHandlers),
-      Layer.provide([passthroughAuthorization, passthroughInstanceContext, testWorkspaceRouting, fakeSession]),
-    ),
-    { disableListenLog: true, disableLogger: true },
-  ).pipe(Layer.provideMerge(NodeHttpServer.layerTest)),
-)
-
-describe("mcp HttpApi OAuth", () => {
-  it.live("preserves oauth state when starting OAuth", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClientRequest.post(McpPaths.auth.replace(":name", "demo")).pipe(HttpClient.execute)
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toEqual({
-        authorizationUrl: "https://auth.example/start",
-        oauthState: "state-123",
-      })
-    }),
-  )
-})
@@ -1,16 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { handlePtyInput } from "../../src/pty/input"
-
-describe("pty HttpApi websocket input", () => {
-  test("does not forward invalid binary frames to the PTY handler", async () => {
-    const messages: Array<string | ArrayBuffer> = []
-    const handler = { onMessage: (message: string | ArrayBuffer) => messages.push(message) }
-
-    await Effect.runPromise(handlePtyInput(handler, "ready"))
-    await Effect.runPromise(handlePtyInput(handler, new Uint8Array([0xff, 0xfe, 0xfd])))
-    await Effect.runPromise(handlePtyInput(handler, new TextEncoder().encode("hello")))
-
-    expect(messages).toEqual(["ready", "hello"])
-  })
-})
@@ -404,7 +404,7 @@ describe("HttpApi SDK", () => {
            lsp,
          }),
          project: { worktreeSelected: record(project.data).worktree === directory },
-          paths: { directorySelected: record(paths.data).directory === directory },
+          paths: { cwdSelected: record(paths.data).cwd === directory },
          file: record(file.data).content,
          hasProject: array(projects.data).length > 0,
          foundFile: JSON.stringify(findFiles.data).includes("hello.txt"),
@@ -1,6 +1,4 @@
 import { afterEach, describe, expect } from "bun:test"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
 import { Effect } from "effect"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { PermissionID } from "../../src/permission/schema"
@@ -11,10 +9,7 @@ import { SessionPaths } from "../../src/server/routes/instance/httpapi/groups/se
 import { Session } from "@/session/session"
 import { MessageID, PartID, type SessionID } from "../../src/session/schema"
 import { MessageV2 } from "../../src/session/message-v2"
-import { Database } from "@/storage/db"
-import { SessionTable } from "@/session/session.sql"
 import * as Log from "@opencode-ai/core/util/log"
-import { eq } from "drizzle-orm"
 import { resetDatabase } from "../fixture/db"
 import { tmpdir } from "../fixture/fixture"
 import { it } from "../lib/effect"
@@ -23,9 +18,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
 }

 function runSession<A, E>(fx: Effect.Effect<A, E, Session.Service>) {
@@ -81,10 +76,6 @@ function request(path: string, init?: RequestInit) {
  return Effect.promise(async () => app().request(path, init))
 }

-function requestWithBackend(experimental: boolean, path: string, init?: RequestInit) {
-  return Effect.promise(async () => app(experimental).request(path, init))
-}
-
 function json<T>(response: Response) {
  return Effect.promise(async () => {
    if (response.status !== 200) throw new Error(await response.text())
@@ -226,95 +217,6 @@ describe("session HttpApi", () => {
    ),
  )

-  it.live(
-    "matches legacy archived timestamp validation",
-    withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const headers = { "x-opencode-directory": tmp.path, "content-type": "application/json" }
-        const legacy = yield* createSession(tmp.path, { title: "legacy" })
-        const effect = yield* createSession(tmp.path, { title: "effect" })
-        const body = JSON.stringify({ time: { archived: -1 } })
-
-        const legacyResponse = yield* requestWithBackend(
-          false,
-          pathFor(SessionPaths.update, { sessionID: legacy.id }),
-          {
-            method: "PATCH",
-            headers,
-            body,
-          },
-        )
-        expect(legacyResponse.status).toBe(200)
-        expect((yield* json<Session.Info>(legacyResponse)).time.archived).toBe(-1)
-
-        const effectResponse = yield* requestWithBackend(true, pathFor(SessionPaths.update, { sessionID: effect.id }), {
-          method: "PATCH",
-          headers,
-          body,
-        })
-        expect(effectResponse.status).toBe(legacyResponse.status)
-        expect((yield* json<Session.Info>(effectResponse)).time.archived).toBe(-1)
-      }),
-    ),
-  )
-
-  it.live(
-    "matches legacy project-scoped path and directory precedence",
-    withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const currentDir = path.join(tmp.path, "packages", "opencode", "src")
-        yield* Effect.promise(() => mkdir(currentDir, { recursive: true }))
-
-        const pathSession = yield* createSession(currentDir)
-        const pathlessSession = yield* createSession(currentDir)
-        yield* Effect.sync(() =>
-          Database.use((db) =>
-            db.update(SessionTable).set({ path: null }).where(eq(SessionTable.id, pathlessSession.id)).run(),
-          ),
-        )
-
-        const query = new URLSearchParams({
-          scope: "project",
-          path: "packages/opencode/src",
-          directory: currentDir,
-        })
-        const headers = { "x-opencode-directory": tmp.path }
-        const legacy = (yield* json<Session.Info[]>(
-          yield* requestWithBackend(false, `${SessionPaths.list}?${query}`, { headers }),
-        )).map((item) => item.id)
-        const effect = (yield* json<Session.Info[]>(
-          yield* requestWithBackend(true, `${SessionPaths.list}?${query}`, { headers }),
-        )).map((item) => item.id)
-
-        expect(legacy).toContain(pathSession.id)
-        expect(legacy).not.toContain(pathlessSession.id)
-        expect(effect).toEqual(legacy)
-      }),
-    ),
-  )
-
-  it.live(
-    "matches legacy paginated message link headers",
-    withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const headers = { "x-opencode-directory": tmp.path }
-        const session = yield* createSession(tmp.path, { title: "messages" })
-        yield* createTextMessage(tmp.path, session.id, "first")
-        yield* createTextMessage(tmp.path, session.id, "second")
-        const route = `${pathFor(SessionPaths.messages, { sessionID: session.id })}?limit=1`
-
-        const legacy = yield* requestWithBackend(false, route, { headers })
-        const effect = yield* requestWithBackend(true, route, { headers })
-
-        expect(effect.headers.get("x-next-cursor")).toBe(legacy.headers.get("x-next-cursor"))
-        expect(effect.headers.get("link")).toBe(legacy.headers.get("link"))
-        expect(effect.headers.get("access-control-expose-headers")).toBe(
-          legacy.headers.get("access-control-expose-headers"),
-        )
-      }),
-    ),
-  )
-
  it.live(
    "serves message mutation routes through Hono bridge",
    withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
@@ -1,8 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test"
 import type { Context } from "hono"
 import { Flag } from "@opencode-ai/core/flag/flag"
-import { GlobalBus } from "../../src/bus/global"
-import { TuiEvent } from "../../src/cli/cmd/tui/event"
 import { SessionID } from "../../src/session/schema"
 import { Instance } from "../../src/project/instance"
 import { TuiApi, TuiPaths } from "../../src/server/routes/instance/httpapi/groups/tui"
@@ -17,20 +15,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 nextCommandExecute() {
-  return new Promise<unknown>((resolve) => {
-    const listener = (event: { payload: { type?: string; properties?: { command?: unknown } } }) => {
-      if (event.payload.type !== TuiEvent.CommandExecute.type) return
-      GlobalBus.off("event", listener)
-      resolve(event.payload.properties?.command)
-    }
-    GlobalBus.on("event", listener)
-  })
+function app() {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = true
+  return Server.Default().app
 }

 async function expectTrue(path: string, headers: Record<string, string>, body?: unknown) {
@@ -85,27 +72,6 @@ describe("tui HttpApi bridge", () => {
    expect(missing.status).toBe(404)
  })

-  test("matches legacy unknown execute command behavior", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-opencode-directory": tmp.path, "content-type": "application/json" }
-    const body = JSON.stringify({ command: "unknown_command" })
-
-    const legacyCommand = nextCommandExecute()
-    const legacy = await app(false).request(TuiPaths.executeCommand, { method: "POST", headers, body })
-    expect(legacy.status).toBe(200)
-    expect(await legacy.json()).toBe(true)
-
-    const effectCommand = nextCommandExecute()
-    const effect = await app().request(TuiPaths.executeCommand, { method: "POST", headers, body })
-    expect(effect.status).toBe(200)
-    expect(await effect.json()).toBe(true)
-
-    const legacyPublished = await legacyCommand
-    const effectPublished = await effectCommand
-    expect(effectPublished).toBe(legacyPublished)
-    expect(legacyPublished).toBeUndefined()
-  })
-
  test("serves TUI control queue through experimental Effect routes", async () => {
    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
    const pending = callTui({ req: { json: async () => ({ value: 1 }), path: "/demo" } } as unknown as Context)
@@ -20,7 +20,6 @@ import type { WorkspaceAdaptor } from "../../src/control-plane/types"
 import { Workspace } from "../../src/control-plane/workspace"
 import { WorkspaceTable } from "../../src/control-plane/workspace.sql"
 import { Project } from "../../src/project/project"
-import { WorkspacePaths } from "../../src/server/routes/instance/httpapi/groups/workspace"
 import {
  WorkspaceRouteContext,
  workspaceRouterMiddleware,
@@ -388,36 +387,6 @@ describe("HttpApi workspace routing middleware", () => {
    }),
  )

-  it.live("keeps workspace control routes local even when workspace is selected", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const workspace = yield* createLocalWorkspace({
-        projectID: project.project.id,
-        type: "workspace-control-plane-target",
-        directory: workspaceDir,
-      })
-
-      // Workspace CRUD/status routes manage the control plane itself. Selecting
-      // a workspace should preserve the selected id for handlers, but must not
-      // swap the route context to the workspace target directory.
-      yield* HttpRouter.add(
-        "GET",
-        WorkspacePaths.list,
-        Effect.gen(function* () {
-          const route = yield* WorkspaceRouteContext
-          return yield* HttpServerResponse.json({ directory: route.directory, workspaceID: route.workspaceID })
-        }),
-      ).pipe(Layer.provide(workspaceRoutingTestLayer), HttpRouter.serve, Layer.build)
-
-      const response = yield* HttpClient.get(`${WorkspacePaths.list}?workspace=${workspace.id}`)
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toEqual({ directory: process.cwd(), workspaceID: workspace.id })
-    }),
-  )
-
  it.live("uses directory query/header fallback when no workspace is selected", () =>
    Effect.gen(function* () {
      const dir = yield* tmpdirScoped()
@@ -179,6 +179,18 @@ describe("workspace HttpApi", () => {
    const workspace = (await created.json()) as Workspace.Info
    expect(workspace).toMatchObject({ type: "local-test", name: "local-test" })

+    const session = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => runSession(Session.Service.use((svc) => svc.create({}))),
+    })
+    const restored = await request(WorkspacePaths.sessionRestore.replace(":id", workspace.id), tmp.path, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ sessionID: session.id }),
+    })
+    expect(restored.status).toBe(200)
+    expect((await restored.json()) as { total: number }).toMatchObject({ total: expect.any(Number) })
+
    const removed = await request(WorkspacePaths.remove.replace(":id", workspace.id), tmp.path, { method: "DELETE" })
    expect(removed.status).toBe(200)
    expect(await removed.json()).toMatchObject({ id: workspace.id })
@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import path from "path"
+import { GlobalBus, type GlobalEvent } from "../../src/bus/global"
+import { Instance } from "../../src/project/instance"
+import { Server } from "../../src/server/server"
+import * as Log from "@opencode-ai/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const originalHttpApi = Flag.OPENCODE_EXPERIMENTAL_HTTPAPI
+type SyncTrace = { type: string; directory?: string }
+
+function app() {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = false
+  return Server.Default().app
+}
+
+function route(pathname: string, directory: string, query?: Record<string, string>) {
+  const url = new URL(pathname, "http://localhost")
+  url.searchParams.set("directory", directory)
+  for (const [key, value] of Object.entries(query ?? {})) {
+    url.searchParams.set(key, value)
+  }
+  return url
+}
+
+async function fetchJson<T>(
+  pathname: string,
+  directory: string,
+  init?: RequestInit,
+  query?: Record<string, string>,
+) {
+  const response = await app().fetch(new Request(route(pathname, directory, query), init))
+  if (response.status !== 200) throw new Error(await response.text())
+  return (await response.json()) as T
+}
+
+function pathFor(pathname: string, params: Record<string, string>) {
+  return Object.entries(params).reduce((result, [key, value]) => result.replace(`:${key}`, value), pathname)
+}
+
+afterEach(async () => {
+  Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = originalHttpApi
+  await Instance.disposeAll()
+  await resetDatabase()
+})
+
+describe("Hono session routes", () => {
+  test("use request directory for non-session routes and saved session directory for session routes", async () => {
+    await using sessionDir = await tmpdir({
+      git: true,
+      config: { formatter: false, lsp: false },
+      init: (dir) => Bun.write(path.join(dir, "marker.txt"), "session-directory"),
+    })
+    await using requestDir = await tmpdir({
+      git: true,
+      config: { formatter: false, lsp: false },
+      init: (dir) => Bun.write(path.join(dir, "marker.txt"), "request-directory"),
+    })
+
+    const json = { "content-type": "application/json" }
+    const trace: SyncTrace[] = []
+    const onEvent = (event: GlobalEvent) => {
+      if (event.payload.type !== "sync") return
+      if (!["session.created.1", "message.updated.1", "message.part.updated.1"].includes(event.payload.syncEvent.type)) return
+      trace.push({ type: event.payload.syncEvent.type, directory: event.directory })
+    }
+    GlobalBus.on("event", onEvent)
+
+    const session = await fetchJson<{ id: string }>("/session", sessionDir.path, {
+      method: "POST",
+      headers: json,
+      body: JSON.stringify({ title: "session-dir" }),
+    })
+
+    const currentPath = await fetchJson<{ directory: string }>("/path", requestDir.path)
+    expect(currentPath.directory).toBe(requestDir.path)
+
+    const marker = await fetchJson<{ type: string; content: string }>(
+      "/file/content",
+      requestDir.path,
+      undefined,
+      {
+        path: "marker.txt",
+      },
+    )
+    expect(marker).toMatchObject({ type: "text", content: "request-directory" })
+
+    await fetchJson<unknown>(pathFor("/session/:sessionID", { sessionID: session.id }), requestDir.path)
+
+    await fetchJson<unknown>(
+      pathFor("/session/:sessionID/fork", { sessionID: session.id }),
+      requestDir.path,
+      {
+        method: "POST",
+        headers: json,
+        body: JSON.stringify({}),
+      },
+    )
+
+    await fetchJson<{ info: { path: { cwd: string; root: string } }; parts: unknown[] }>(
+      pathFor("/session/:sessionID/shell", { sessionID: session.id }),
+      requestDir.path,
+      {
+        method: "POST",
+        headers: json,
+        body: JSON.stringify({
+          agent: "build",
+          model: { providerID: "test", modelID: "test" },
+          command: "pwd",
+        }),
+      },
+    )
+    GlobalBus.off("event", onEvent)
+
+    expect(trace).toContainEqual({ type: "session.created.1", directory: sessionDir.path })
+    expect(trace.filter((event) => event.type === "session.created.1")).toEqual([
+      { type: "session.created.1", directory: sessionDir.path },
+      { type: "session.created.1", directory: sessionDir.path },
+    ])
+    expect(trace.filter((event) => event.type === "message.updated.1").map((event) => event.directory)).toEqual(
+      expect.arrayContaining([sessionDir.path]),
+    )
+    expect(trace.filter((event) => event.type === "message.updated.1").every((event) => event.directory === sessionDir.path))
+      .toBe(true)
+  })
+})
@@ -1,76 +1,16 @@
-import { describe, expect, test } from "bun:test"
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import path from "path"
-import { Effect, FileSystem, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { NodeFileSystem } from "@effect/platform-node"
-import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { AppFileSystem } from "@opencode-ai/core/filesystem"
-import { Config } from "@/config/config"
-import { emptyConsoleState } from "@/config/console-state"
+import { Effect } from "effect"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { Instruction } from "../../src/session/instruction"
 import type { MessageV2 } from "../../src/session/message-v2"
+import { Instance } from "../../src/project/instance"
 import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { Global } from "@opencode-ai/core/global"
-import { provideInstance, provideTmpdirInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
+import { tmpdir } from "../fixture/fixture"

-const it = testEffect(Layer.mergeAll(CrossSpawnSpawner.defaultLayer, NodeFileSystem.layer))
-
-const configLayer = Layer.succeed(
-  Config.Service,
-  Config.Service.of({
-    get: () => Effect.succeed({}),
-    getGlobal: () => Effect.succeed({}),
-    getConsoleState: () => Effect.succeed(emptyConsoleState),
-    update: () => Effect.void,
-    updateGlobal: (config) => Effect.succeed(config),
-    invalidate: () => Effect.void,
-    directories: () => Effect.succeed([]),
-    waitForDependencies: () => Effect.void,
-  }),
-)
-
-const instructionLayer = (global: Partial<Global.Interface>) =>
-  Instruction.layer.pipe(
-    Layer.provide(configLayer),
-    Layer.provide(AppFileSystem.defaultLayer),
-    Layer.provide(FetchHttpClient.layer),
-    Layer.provide(Global.layerWith(global)),
-  )
-
-const provideInstruction =
-  (global: Partial<Global.Interface>) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    self.pipe(Effect.provide(instructionLayer(global)))
-
-const write = (filepath: string, content: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    yield* fs.makeDirectory(path.dirname(filepath), { recursive: true })
-    yield* fs.writeFileString(filepath, content)
-  })
-
-const writeFiles = (dir: string, files: Record<string, string>) =>
-  Effect.all(
-    Object.entries(files).map(([file, content]) => write(path.join(dir, file), content)),
-    { discard: true },
-  )
-
-const withFiles = <A, E, R>(files: Record<string, string>, self: (dir: string) => Effect.Effect<A, E, R>) =>
-  provideTmpdirInstance((dir) =>
-    Effect.gen(function* () {
-      yield* writeFiles(dir, files)
-      return yield* self(dir).pipe(provideInstruction({ home: dir, config: dir }))
-    }),
-  )
-
-const tmpWithFiles = (files: Record<string, string>) =>
-  Effect.gen(function* () {
-    const dir = yield* tmpdirScoped()
-    yield* writeFiles(dir, files)
-    return dir
-  })
+const run = <A>(effect: Effect.Effect<A, any, Instruction.Service>) =>
+  Effect.runPromise(effect.pipe(Effect.provide(Instruction.defaultLayer)))

 function loaded(filepath: string): MessageV2.WithParts[] {
  const sessionID = SessionID.make("session-loaded-1")
@@ -112,135 +52,336 @@ function loaded(filepath: string): MessageV2.WithParts[] {
 }

 describe("Instruction.resolve", () => {
-  it.live("returns empty when AGENTS.md is at project root (already in systemPaths)", () =>
-    withFiles({ "AGENTS.md": "# Root Instructions", "src/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const system = yield* svc.systemPaths()
-        expect(system.has(path.join(dir, "AGENTS.md"))).toBe(true)
+  test("returns empty when AGENTS.md is at project root (already in systemPaths)", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Root Instructions")
+        await Bun.write(path.join(dir, "src", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const system = yield* svc.systemPaths()
+              expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)

-        const results = yield* svc.resolve([], path.join(dir, "src", "file.ts"), MessageID.make("message-test-1"))
-        expect(results).toEqual([])
-      }),
-    ),
-  )
+              const results = yield* svc.resolve(
+                [],
+                path.join(tmp.path, "src", "file.ts"),
+                MessageID.make("message-test-1"),
+              )
+              expect(results).toEqual([])
+            }),
+          ),
+        ),
+    })
+  })

-  it.live("returns AGENTS.md from subdirectory (not in systemPaths)", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const system = yield* svc.systemPaths()
-        expect(system.has(path.join(dir, "subdir", "AGENTS.md"))).toBe(false)
+  test("returns AGENTS.md from subdirectory (not in systemPaths)", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const system = yield* svc.systemPaths()
+              expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)

-        const results = yield* svc.resolve(
-          [],
-          path.join(dir, "subdir", "nested", "file.ts"),
-          MessageID.make("message-test-2"),
-        )
-        expect(results.length).toBe(1)
-        expect(results[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-      }),
-    ),
-  )
+              const results = yield* svc.resolve(
+                [],
+                path.join(tmp.path, "subdir", "nested", "file.ts"),
+                MessageID.make("message-test-2"),
+              )
+              expect(results.length).toBe(1)
+              expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+            }),
+          ),
+        ),
+    })
+  })

-  it.live("doesn't reload AGENTS.md when reading it directly", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "AGENTS.md")
-        const system = yield* svc.systemPaths()
-        expect(system.has(filepath)).toBe(false)
+  test("doesn't reload AGENTS.md when reading it directly", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
+              const system = yield* svc.systemPaths()
+              expect(system.has(filepath)).toBe(false)

-        const results = yield* svc.resolve([], filepath, MessageID.make("message-test-3"))
-        expect(results).toEqual([])
-      }),
-    ),
-  )
+              const results = yield* svc.resolve([], filepath, MessageID.make("message-test-3"))
+              expect(results).toEqual([])
+            }),
+          ),
+        ),
+    })
+  })

-  it.live("does not reattach the same nearby instructions twice for one message", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("message-claim-1")
+  test("does not reattach the same nearby instructions twice for one message", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+              const id = MessageID.make("message-claim-1")

-        const first = yield* svc.resolve([], filepath, id)
-        const second = yield* svc.resolve([], filepath, id)
+              const first = yield* svc.resolve([], filepath, id)
+              const second = yield* svc.resolve([], filepath, id)

-        expect(first).toHaveLength(1)
-        expect(first[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-        expect(second).toEqual([])
-      }),
-    ),
-  )
+              expect(first).toHaveLength(1)
+              expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+              expect(second).toEqual([])
+            }),
+          ),
+        ),
+    })
+  })

-  it.live("clear allows nearby instructions to be attached again for the same message", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("message-claim-2")
+  test("clear allows nearby instructions to be attached again for the same message", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+              const id = MessageID.make("message-claim-2")

-        const first = yield* svc.resolve([], filepath, id)
-        yield* svc.clear(id)
-        const second = yield* svc.resolve([], filepath, id)
+              const first = yield* svc.resolve([], filepath, id)
+              yield* svc.clear(id)
+              const second = yield* svc.resolve([], filepath, id)

-        expect(first).toHaveLength(1)
-        expect(second).toHaveLength(1)
-        expect(second[0].filepath).toBe(path.join(dir, "subdir", "AGENTS.md"))
-      }),
-    ),
-  )
+              expect(first).toHaveLength(1)
+              expect(second).toHaveLength(1)
+              expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
+            }),
+          ),
+        ),
+    })
+  })

-  it.live("skips instructions already reported by prior read metadata", () =>
-    withFiles({ "subdir/AGENTS.md": "# Subdir Instructions", "subdir/nested/file.ts": "const x = 1" }, (dir) =>
-      Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const agents = path.join(dir, "subdir", "AGENTS.md")
-        const filepath = path.join(dir, "subdir", "nested", "file.ts")
-        const id = MessageID.make("message-claim-3")
+  test("skips instructions already reported by prior read metadata", async () => {
+    await using tmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
+        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
+      },
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: () =>
+        run(
+          Instruction.Service.use((svc) =>
+            Effect.gen(function* () {
+              const agents = path.join(tmp.path, "subdir", "AGENTS.md")
+              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
+              const id = MessageID.make("message-claim-3")

-        const results = yield* svc.resolve(loaded(agents), filepath, id)
-        expect(results).toEqual([])
-      }),
-    ),
-  )
+              const results = yield* svc.resolve(loaded(agents), filepath, id)
+              expect(results).toEqual([])
+            }),
+          ),
+        ),
+    })
+  })

  test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
 })

 describe("Instruction.system", () => {
-  it.live("loads both project and global AGENTS.md when both exist", () =>
-    Effect.gen(function* () {
-      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
-      const projectTmp = yield* tmpWithFiles({ "AGENTS.md": "# Project Instructions" })
+  test("loads both project and global AGENTS.md when both exist", async () => {
+    const originalConfigDir = process.env["OPENCODE_CONFIG_DIR"]
+    delete process.env["OPENCODE_CONFIG_DIR"]

-      yield* Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const paths = yield* svc.systemPaths()
-        expect(paths.has(path.join(projectTmp, "AGENTS.md"))).toBe(true)
-        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Project Instructions")
+      },
+    })

-        const rules = yield* svc.system()
-        expect(rules).toHaveLength(2)
-        expect(rules[0]).toBe(`Instructions from: ${path.join(globalTmp, "AGENTS.md")}\n# Global Instructions`)
-        expect(rules[1]).toBe(`Instructions from: ${path.join(projectTmp, "AGENTS.md")}\n# Project Instructions`)
-      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
-    }),
-  )
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: () =>
+          run(
+            Instruction.Service.use((svc) =>
+              Effect.gen(function* () {
+                const paths = yield* svc.systemPaths()
+                expect(paths.has(path.join(projectTmp.path, "AGENTS.md"))).toBe(true)
+                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+
+                const rules = yield* svc.system()
+                expect(rules).toHaveLength(2)
+                expect(rules[0]).toBe(
+                  `Instructions from: ${path.join(globalTmp.path, "AGENTS.md")}\n# Global Instructions`,
+                )
+                expect(rules[1]).toBe(
+                  `Instructions from: ${path.join(projectTmp.path, "AGENTS.md")}\n# Project Instructions`,
+                )
+              }),
+            ),
+          ),
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+      if (originalConfigDir === undefined) {
+        delete process.env["OPENCODE_CONFIG_DIR"]
+      } else {
+        process.env["OPENCODE_CONFIG_DIR"] = originalConfigDir
+      }
+    }
+  })
 })

-describe("Instruction.systemPaths global config", () => {
-  it.live("uses Global.Service config AGENTS.md", () =>
-    Effect.gen(function* () {
-      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
-      const projectTmp = yield* tmpdirScoped()
+describe("Instruction.systemPaths OPENCODE_CONFIG_DIR", () => {
+  let originalConfigDir: string | undefined

-      yield* Effect.gen(function* () {
-        const svc = yield* Instruction.Service
-        const paths = yield* svc.systemPaths()
-        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
-      }).pipe(provideInstance(projectTmp), provideInstruction({ home: globalTmp, config: globalTmp }))
-    }),
-  )
+  beforeEach(() => {
+    originalConfigDir = process.env["OPENCODE_CONFIG_DIR"]
+  })
+
+  afterEach(() => {
+    if (originalConfigDir === undefined) {
+      delete process.env["OPENCODE_CONFIG_DIR"]
+    } else {
+      process.env["OPENCODE_CONFIG_DIR"] = originalConfigDir
+    }
+  })
+
+  test("prefers OPENCODE_CONFIG_DIR AGENTS.md over global when both exist", async () => {
+    await using profileTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Profile Instructions")
+      },
+    })
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    process.env["OPENCODE_CONFIG_DIR"] = profileTmp.path
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: () =>
+          run(
+            Instruction.Service.use((svc) =>
+              Effect.gen(function* () {
+                const paths = yield* svc.systemPaths()
+                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
+                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
+              }),
+            ),
+          ),
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
+
+  test("falls back to global AGENTS.md when OPENCODE_CONFIG_DIR has no AGENTS.md", async () => {
+    await using profileTmp = await tmpdir()
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    process.env["OPENCODE_CONFIG_DIR"] = profileTmp.path
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: () =>
+          run(
+            Instruction.Service.use((svc) =>
+              Effect.gen(function* () {
+                const paths = yield* svc.systemPaths()
+                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
+                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+              }),
+            ),
+          ),
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
+
+  test("uses global AGENTS.md when OPENCODE_CONFIG_DIR is not set", async () => {
+    await using globalTmp = await tmpdir({
+      init: async (dir) => {
+        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
+      },
+    })
+    await using projectTmp = await tmpdir()
+
+    delete process.env["OPENCODE_CONFIG_DIR"]
+    const originalGlobalConfig = Global.Path.config
+    ;(Global.Path as { config: string }).config = globalTmp.path
+
+    try {
+      await Instance.provide({
+        directory: projectTmp.path,
+        fn: () =>
+          run(
+            Instruction.Service.use((svc) =>
+              Effect.gen(function* () {
+                const paths = yield* svc.systemPaths()
+                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
+              }),
+            ),
+          ),
+      })
+    } finally {
+      ;(Global.Path as { config: string }).config = originalGlobalConfig
+    }
+  })
 })
@@ -5,7 +5,7 @@ import { Bus } from "../../src/bus"
 import { Instance } from "../../src/project/instance"
 import { SyncEvent } from "../../src/sync"
 import { Database } from "@/storage/db"
-import { EventSequenceTable, EventTable } from "../../src/sync/event.sql"
+import { EventTable } from "../../src/sync/event.sql"
 import { Identifier } from "../../src/id/id"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { initProjectors } from "../../src/server/projectors"
@@ -233,72 +233,5 @@ describe("SyncEvent", () => {
        expect(rows.map((row) => row.seq)).toEqual([0, 1, 2, 3])
      }),
    )
-
-    test(
-      "claims unowned event sequence on replay with ownerID",
-      withInstance(() => {
-        const { Created } = setup()
-        const id = Identifier.descending("message")
-
-        SyncEvent.replay(
-          {
-            id: "evt_1",
-            type: SyncEvent.versionedType(Created.type, Created.version),
-            seq: 0,
-            aggregateID: id,
-            data: { id, name: "owned" },
-          },
-          { publish: false, ownerID: "owner-1" },
-        )
-
-        const row = Database.use((db) =>
-          db
-            .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-            .from(EventSequenceTable)
-            .get(),
-        )
-        expect(row).toEqual({ seq: 0, ownerID: "owner-1" })
-      }),
-    )
-
-    test(
-      "ignores replay from a different owner after sequence is claimed",
-      withInstance(() => {
-        const { Created } = setup()
-        const id = Identifier.descending("message")
-
-        SyncEvent.replay(
-          {
-            id: "evt_1",
-            type: SyncEvent.versionedType(Created.type, Created.version),
-            seq: 0,
-            aggregateID: id,
-            data: { id, name: "first" },
-          },
-          { publish: false, ownerID: "owner-1" },
-        )
-        SyncEvent.replay(
-          {
-            id: "evt_2",
-            type: SyncEvent.versionedType(Created.type, Created.version),
-            seq: 1,
-            aggregateID: id,
-            data: { id, name: "ignored" },
-          },
-          { publish: false, ownerID: "owner-2" },
-        )
-
-        const events = Database.use((db) => db.select().from(EventTable).all())
-        const sequence = Database.use((db) =>
-          db
-            .select({ seq: EventSequenceTable.seq, ownerID: EventSequenceTable.owner_id })
-            .from(EventSequenceTable)
-            .get(),
-        )
-        expect(events).toHaveLength(1)
-        expect(events[0].id).toBe("evt_1")
-        expect(sequence).toEqual({ seq: 0, ownerID: "owner-1" })
-      }),
-    )
  })
 })
@@ -0,0 +1,283 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
+import fs from "node:fs/promises"
+import path from "node:path"
+import { GlobalBus } from "../../src/bus/global"
+import { registerAdaptor } from "../../src/control-plane/adaptors"
+import type { WorkspaceAdaptor } from "../../src/control-plane/types"
+import { Workspace } from "../../src/control-plane/workspace"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { Flag } from "@opencode-ai/core/flag/flag"
+import { ModelID, ProviderID } from "../../src/provider/schema"
+import { Instance } from "../../src/project/instance"
+import { Session as SessionNs } from "@/session/session"
+import { MessageV2 } from "../../src/session/message-v2"
+import { MessageID, PartID, type SessionID } from "../../src/session/schema"
+import { Database } from "@/storage/db"
+import { asc } from "drizzle-orm"
+import { eq } from "drizzle-orm"
+import { SyncEvent } from "../../src/sync"
+import { EventTable } from "../../src/sync/event.sql"
+import * as Log from "@opencode-ai/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { tmpdir } from "../fixture/fixture"
+
+void Log.init({ print: false })
+
+const original = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
+
+beforeEach(() => {
+  Database.close()
+  Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = true
+})
+
+afterEach(async () => {
+  mock.restore()
+  await Instance.disposeAll()
+  Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = original
+  await resetDatabase()
+})
+
+function create(input?: SessionNs.CreateInput) {
+  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create(input)))
+}
+
+function get(id: SessionID) {
+  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.get(id)))
+}
+
+function updateMessage<T extends MessageV2.Info>(msg: T) {
+  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updateMessage(msg)))
+}
+
+function updatePart<T extends MessageV2.Part>(part: T) {
+  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updatePart(part)))
+}
+
+async function user(sessionID: SessionID, text: string) {
+  const msg = await updateMessage({
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID,
+    agent: "build",
+    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
+    time: { created: Date.now() },
+  })
+  await updatePart({
+    id: PartID.ascending(),
+    sessionID,
+    messageID: msg.id,
+    type: "text",
+    text,
+  })
+}
+
+function remote(dir: string, url: string): WorkspaceAdaptor {
+  return {
+    name: "remote",
+    description: "remote",
+    configure(info) {
+      return {
+        ...info,
+        directory: dir,
+      }
+    },
+    async create() {
+      await fs.mkdir(dir, { recursive: true })
+    },
+    async remove() {},
+    target() {
+      return {
+        type: "remote" as const,
+        url,
+      }
+    },
+  }
+}
+
+function local(dir: string): WorkspaceAdaptor {
+  return {
+    name: "local",
+    description: "local",
+    configure(info) {
+      return {
+        ...info,
+        directory: dir,
+      }
+    },
+    async create() {
+      await fs.mkdir(dir, { recursive: true })
+    },
+    async remove() {},
+    target() {
+      return {
+        type: "local" as const,
+        directory: dir,
+      }
+    },
+  }
+}
+
+function eventStreamResponse() {
+  return new Response(new ReadableStream({ start() {} }), {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream",
+    },
+  })
+}
+
+describe("Workspace.sessionRestore", () => {
+  test("replays session events in batches of 10 and emits progress", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const dir = path.join(tmp.path, ".restore")
+    const seen: any[] = []
+    const posts: Array<{
+      path: string
+      body: { directory: string; events: Array<{ seq: number; aggregateID: string }> }
+    }> = []
+    const on = (evt: any) => seen.push(evt)
+    GlobalBus.on("event", on)
+
+    const raw = globalThis.fetch
+    spyOn(globalThis, "fetch").mockImplementation(
+      Object.assign(
+        async (input: URL | RequestInfo, init?: BunFetchRequestInit | RequestInit) => {
+          const url = new URL(typeof input === "string" || input instanceof URL ? input : input.url)
+          if (url.pathname === "/base/global/event") {
+            return eventStreamResponse()
+          }
+          if (url.pathname === "/base/sync/history") {
+            return Response.json([])
+          }
+          const body = JSON.parse(String(init?.body))
+          posts.push({
+            path: url.pathname,
+            body,
+          })
+          return Response.json({ sessionID: body.events[0].aggregateID })
+        },
+        {
+          preconnect: raw.preconnect?.bind(raw),
+        },
+      ) as typeof globalThis.fetch,
+    )
+
+    try {
+      const setup = await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          registerAdaptor(Instance.project.id, "worktree", remote(dir, "https://workspace.test/base"))
+          const space = await Workspace.create({
+            type: "worktree",
+            branch: null,
+            extra: null,
+            projectID: Instance.project.id,
+          })
+          const session = await create({})
+          for (let i = 0; i < 6; i++) {
+            await user(session.id, `msg ${i}`)
+          }
+          const rows = Database.use((db) =>
+            db
+              .select({ seq: EventTable.seq })
+              .from(EventTable)
+              .where(eq(EventTable.aggregate_id, session.id))
+              .orderBy(asc(EventTable.seq))
+              .all(),
+          )
+          const result = await Workspace.sessionRestore({
+            workspaceID: space.id,
+            sessionID: session.id,
+          })
+          return { space, session, rows, result }
+        },
+      })
+
+      expect(setup.rows).toHaveLength(13)
+      expect(setup.result).toEqual({ total: 2 })
+      expect(posts).toHaveLength(2)
+      expect(posts[0]?.path).toBe("/base/sync/replay")
+      expect(posts[1]?.path).toBe("/base/sync/replay")
+      expect(posts[0]?.body.directory).toBe(dir)
+      expect(posts[1]?.body.directory).toBe(dir)
+      expect(posts[0]?.body.events).toHaveLength(10)
+      expect(posts[1]?.body.events).toHaveLength(4)
+      expect(posts.flatMap((item) => item.body.events.map((event) => event.seq))).toEqual([
+        ...setup.rows.map((row) => row.seq),
+        setup.rows.at(-1)!.seq + 1,
+      ])
+      expect(posts[1]?.body.events.at(-1)).toMatchObject({
+        aggregateID: setup.session.id,
+        seq: setup.rows.at(-1)!.seq + 1,
+        type: SyncEvent.versionedType(SessionNs.Event.Updated.type, SessionNs.Event.Updated.version),
+        data: {
+          sessionID: setup.session.id,
+          info: {
+            workspaceID: setup.space.id,
+          },
+        },
+      })
+
+      const restore = seen.filter(
+        (evt) => evt.workspace === setup.space.id && evt.payload.type === Workspace.Event.Restore.type,
+      )
+      expect(restore.map((evt) => evt.payload.properties.step)).toEqual([0, 1, 2])
+      expect(restore.map((evt) => evt.payload.properties.total)).toEqual([2, 2, 2])
+      expect(restore.map((evt) => evt.payload.properties.sessionID)).toEqual([
+        setup.session.id,
+        setup.session.id,
+        setup.session.id,
+      ])
+    } finally {
+      GlobalBus.off("event", on)
+    }
+  })
+
+  test("replays locally without posting to a server", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const dir = path.join(tmp.path, ".restore-local")
+    const seen: any[] = []
+    const on = (evt: any) => seen.push(evt)
+    GlobalBus.on("event", on)
+
+    const fetch = spyOn(globalThis, "fetch")
+    const replayAll = spyOn(SyncEvent, "replayAll")
+
+    try {
+      const setup = await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          registerAdaptor(Instance.project.id, "local-restore", local(dir))
+          const space = await Workspace.create({
+            type: "local-restore",
+            branch: null,
+            extra: null,
+            projectID: Instance.project.id,
+          })
+          const session = await create({})
+          for (let i = 0; i < 6; i++) {
+            await user(session.id, `msg ${i}`)
+          }
+          const result = await Workspace.sessionRestore({
+            workspaceID: space.id,
+            sessionID: session.id,
+          })
+          const updated = await get(session.id)
+          return { space, session, result, updated }
+        },
+      })
+
+      expect(setup.result).toEqual({ total: 2 })
+      expect(fetch).not.toHaveBeenCalled()
+      expect(replayAll).toHaveBeenCalledTimes(2)
+      expect(setup.updated.workspaceID).toBe(setup.space.id)
+
+      const restore = seen.filter(
+        (evt) => evt.workspace === setup.space.id && evt.payload.type === Workspace.Event.Restore.type,
+      )
+      expect(restore.map((evt) => evt.payload.properties.step)).toEqual([0, 1, 2])
+    } finally {
+      GlobalBus.off("event", on)
+    }
+  })
+})
@@ -22,8 +22,8 @@
    "zod": "catalog:"
  },
  "peerDependencies": {
-    "@opentui/core": ">=0.2.0",
-    "@opentui/solid": ">=0.2.0"
+    "@opentui/core": ">=0.1.105",
+    "@opentui/solid": ">=0.1.105"
  },
  "peerDependenciesMeta": {
    "@opentui/core": {
@@ -32,14 +32,12 @@ import type {
  ExperimentalWorkspaceAdaptorListResponses,
  ExperimentalWorkspaceCreateErrors,
  ExperimentalWorkspaceCreateResponses,
-  ExperimentalWorkspaceDetachErrors,
-  ExperimentalWorkspaceDetachResponses,
  ExperimentalWorkspaceListResponses,
  ExperimentalWorkspaceRemoveErrors,
  ExperimentalWorkspaceRemoveResponses,
+  ExperimentalWorkspaceSessionRestoreErrors,
+  ExperimentalWorkspaceSessionRestoreResponses,
  ExperimentalWorkspaceStatusResponses,
-  ExperimentalWorkspaceWarpErrors,
-  ExperimentalWorkspaceWarpResponses,
  FileListResponses,
  FilePartInput,
  FilePartSource,
@@ -167,8 +165,6 @@ import type {
  SyncReplayErrors,
  SyncReplayResponses,
  SyncStartResponses,
-  SyncStealErrors,
-  SyncStealResponses,
  TextPartInput,
  ToolIdsErrors,
  ToolIdsResponses,
@@ -656,49 +652,6 @@ export class Workspace extends HeyApiClient {
    })
  }

-  /**
-   * Warp session into workspace
-   *
-   * Move a session's sync history into the target workspace, or detach it to the local project.
-   */
-  public detach<ThrowOnError extends boolean = false>(
-    parameters?: {
-      directory?: string
-      workspace?: string
-      workspaceID?: string | null
-      sessionID?: string
-    },
-    options?: Options<never, ThrowOnError>,
-  ) {
-    const params = buildClientParams(
-      [parameters],
-      [
-        {
-          args: [
-            { in: "query", key: "directory" },
-            { in: "query", key: "workspace" },
-            { in: "body", key: "workspaceID" },
-            { in: "body", key: "sessionID" },
-          ],
-        },
-      ],
-    )
-    return (options?.client ?? this.client).post<
-      ExperimentalWorkspaceDetachResponses,
-      ExperimentalWorkspaceDetachErrors,
-      ThrowOnError
-    >({
-      url: "/experimental/workspace/warp",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers,
-      },
-    })
-  }
-
  /**
   * Remove workspace
   *
@@ -736,11 +689,11 @@ export class Workspace extends HeyApiClient {
  }

  /**
-   * Warp session into workspace
+   * Restore session into workspace
   *
-   * Move a session's sync history into the target workspace.
+   * Replay a session's sync events into the target workspace in batches.
   */
-  public warp<ThrowOnError extends boolean = false>(
+  public sessionRestore<ThrowOnError extends boolean = false>(
    parameters: {
      id: string
      directory?: string
@@ -763,11 +716,11 @@ export class Workspace extends HeyApiClient {
      ],
    )
    return (options?.client ?? this.client).post<
-      ExperimentalWorkspaceWarpResponses,
-      ExperimentalWorkspaceWarpErrors,
+      ExperimentalWorkspaceSessionRestoreResponses,
+      ExperimentalWorkspaceSessionRestoreErrors,
      ThrowOnError
    >({
-      url: "/experimental/workspace/{id}/warp",
+      url: "/experimental/workspace/{id}/session-restore",
      ...options,
      ...params,
      headers: {
@@ -3220,43 +3173,6 @@ export class Sync extends HeyApiClient {
    })
  }

-  /**
-   * Steal session into workspace
-   *
-   * Update a session to belong to the current workspace through the sync event system.
-   */
-  public steal<ThrowOnError extends boolean = false>(
-    parameters?: {
-      directory?: string
-      workspace?: string
-      sessionID?: string
-    },
-    options?: Options<never, ThrowOnError>,
-  ) {
-    const params = buildClientParams(
-      [parameters],
-      [
-        {
-          args: [
-            { in: "query", key: "directory" },
-            { in: "query", key: "workspace" },
-            { in: "body", key: "sessionID" },
-          ],
-        },
-      ],
-    )
-    return (options?.client ?? this.client).post<SyncStealResponses, SyncStealErrors, ThrowOnError>({
-      url: "/sync/steal",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers,
-      },
-    })
-  }
-
  private _history?: History
  get history(): History {
    return (this._history ??= new History({ client: this.client }))
@@ -452,28 +452,6 @@ export type EventVcsBranchUpdated = {
  }
 }

-export type EventWorkspaceReady = {
-  type: "workspace.ready"
-  properties: {
-    name: string
-  }
-}
-
-export type EventWorkspaceFailed = {
-  type: "workspace.failed"
-  properties: {
-    message: string
-  }
-}
-
-export type EventWorkspaceStatus = {
-  type: "workspace.status"
-  properties: {
-    workspaceID: string
-    status: "connected" | "connecting" | "disconnected" | "error"
-  }
-}
-
 export type EventWorktreeReady = {
  type: "worktree.ready"
  properties: {
@@ -528,6 +506,38 @@ export type EventPtyDeleted = {
  }
 }

+export type EventWorkspaceReady = {
+  type: "workspace.ready"
+  properties: {
+    name: string
+  }
+}
+
+export type EventWorkspaceFailed = {
+  type: "workspace.failed"
+  properties: {
+    message: string
+  }
+}
+
+export type EventWorkspaceRestore = {
+  type: "workspace.restore"
+  properties: {
+    workspaceID: string
+    sessionID: string
+    total: number
+    step: number
+  }
+}
+
+export type EventWorkspaceStatus = {
+  type: "workspace.status"
+  properties: {
+    workspaceID: string
+    status: "connected" | "connecting" | "disconnected" | "error"
+  }
+}
+
 export type OutputFormatText = {
  type: "text"
 }
@@ -1131,15 +1141,16 @@ export type GlobalEvent = {
    | EventMcpBrowserOpenFailed
    | EventCommandExecuted
    | EventVcsBranchUpdated
-    | EventWorkspaceReady
-    | EventWorkspaceFailed
-    | EventWorkspaceStatus
    | EventWorktreeReady
    | EventWorktreeFailed
    | EventPtyCreated
    | EventPtyUpdated
    | EventPtyExited
    | EventPtyDeleted
+    | EventWorkspaceReady
+    | EventWorkspaceFailed
+    | EventWorkspaceRestore
+    | EventWorkspaceStatus
    | EventMessageUpdated
    | EventMessageRemoved
    | EventMessagePartUpdated
@@ -2073,15 +2084,16 @@ export type Event =
  | EventMcpBrowserOpenFailed
  | EventCommandExecuted
  | EventVcsBranchUpdated
-  | EventWorkspaceReady
-  | EventWorkspaceFailed
-  | EventWorkspaceStatus
  | EventWorktreeReady
  | EventWorktreeFailed
  | EventPtyCreated
  | EventPtyUpdated
  | EventPtyExited
  | EventPtyDeleted
+  | EventWorkspaceReady
+  | EventWorkspaceFailed
+  | EventWorkspaceRestore
+  | EventWorkspaceStatus
  | EventMessageUpdated
  | EventMessageRemoved
  | EventMessagePartUpdated
@@ -2520,39 +2532,6 @@ export type ExperimentalWorkspaceStatusResponses = {
 export type ExperimentalWorkspaceStatusResponse =
  ExperimentalWorkspaceStatusResponses[keyof ExperimentalWorkspaceStatusResponses]

-export type ExperimentalWorkspaceDetachData = {
-  body?: {
-    workspaceID: string | null
-    sessionID: string
-  }
-  path?: never
-  query?: {
-    directory?: string
-    workspace?: string
-  }
-  url: "/experimental/workspace/warp"
-}
-
-export type ExperimentalWorkspaceDetachErrors = {
-  /**
-   * Bad request
-   */
-  400: BadRequestError
-}
-
-export type ExperimentalWorkspaceDetachError =
-  ExperimentalWorkspaceDetachErrors[keyof ExperimentalWorkspaceDetachErrors]
-
-export type ExperimentalWorkspaceDetachResponses = {
-  /**
-   * Session warped
-   */
-  204: void
-}
-
-export type ExperimentalWorkspaceDetachResponse =
-  ExperimentalWorkspaceDetachResponses[keyof ExperimentalWorkspaceDetachResponses]
-
 export type ExperimentalWorkspaceRemoveData = {
  body?: never
  path: {
@@ -2585,7 +2564,7 @@ export type ExperimentalWorkspaceRemoveResponses = {
 export type ExperimentalWorkspaceRemoveResponse =
  ExperimentalWorkspaceRemoveResponses[keyof ExperimentalWorkspaceRemoveResponses]

-export type ExperimentalWorkspaceWarpData = {
+export type ExperimentalWorkspaceSessionRestoreData = {
  body?: {
    sessionID: string
  }
@@ -2596,27 +2575,30 @@ export type ExperimentalWorkspaceWarpData = {
    directory?: string
    workspace?: string
  }
-  url: "/experimental/workspace/{id}/warp"
+  url: "/experimental/workspace/{id}/session-restore"
 }

-export type ExperimentalWorkspaceWarpErrors = {
+export type ExperimentalWorkspaceSessionRestoreErrors = {
  /**
   * Bad request
   */
  400: BadRequestError
 }

-export type ExperimentalWorkspaceWarpError = ExperimentalWorkspaceWarpErrors[keyof ExperimentalWorkspaceWarpErrors]
+export type ExperimentalWorkspaceSessionRestoreError =
+  ExperimentalWorkspaceSessionRestoreErrors[keyof ExperimentalWorkspaceSessionRestoreErrors]

-export type ExperimentalWorkspaceWarpResponses = {
+export type ExperimentalWorkspaceSessionRestoreResponses = {
  /**
-   * Session warped
+   * Session replay started
   */
-  204: void
+  200: {
+    total: number
+  }
 }

-export type ExperimentalWorkspaceWarpResponse =
-  ExperimentalWorkspaceWarpResponses[keyof ExperimentalWorkspaceWarpResponses]
+export type ExperimentalWorkspaceSessionRestoreResponse =
+  ExperimentalWorkspaceSessionRestoreResponses[keyof ExperimentalWorkspaceSessionRestoreResponses]

 export type ProjectListData = {
  body?: never
@@ -4644,38 +4626,6 @@ export type SyncReplayResponses = {

 export type SyncReplayResponse = SyncReplayResponses[keyof SyncReplayResponses]

-export type SyncStealData = {
-  body?: {
-    sessionID: string
-  }
-  path?: never
-  query?: {
-    directory?: string
-    workspace?: string
-  }
-  url: "/sync/steal"
-}
-
-export type SyncStealErrors = {
-  /**
-   * Bad request
-   */
-  400: BadRequestError
-}
-
-export type SyncStealError = SyncStealErrors[keyof SyncStealErrors]
-
-export type SyncStealResponses = {
-  /**
-   * Session stolen into workspace
-   */
-  200: {
-    sessionID: string
-  }
-}
-
-export type SyncStealResponse = SyncStealResponses[keyof SyncStealResponses]
-
 export type SyncHistoryListData = {
  body?: {
    [key: string]: number
@@ -5448,80 +5448,6 @@
        ]
      }
    },
-    "/sync/steal": {
-      "post": {
-        "operationId": "sync.steal",
-        "parameters": [
-          {
-            "in": "query",
-            "name": "directory",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "in": "query",
-            "name": "workspace",
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "summary": "Steal session into workspace",
-        "description": "Update a session to belong to the current workspace through the sync event system.",
-        "responses": {
-          "200": {
-            "description": "Session stolen into workspace",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "object",
-                  "properties": {
-                    "sessionID": {
-                      "type": "string",
-                      "pattern": "^ses.*"
-                    }
-                  },
-                  "required": ["sessionID"]
-                }
-              }
-            }
-          },
-          "400": {
-            "description": "Bad request",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/BadRequestError"
-                }
-              }
-            }
-          }
-        },
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "sessionID": {
-                    "type": "string",
-                    "pattern": "^ses.*"
-                  }
-                },
-                "required": ["sessionID"]
-              }
-            }
-          }
-        },
-        "x-codeSamples": [
-          {
-            "lang": "js",
-            "source": "import { createOpencodeClient } from \"@opencode-ai/sdk\n\nconst client = createOpencodeClient()\nawait client.sync.steal({\n  ...\n})"
-          }
-        ]
-      }
-    },
    "/sync/history": {
      "post": {
        "operationId": "sync.history.list",
@@ -8817,102 +8743,6 @@
        },
        "required": ["type", "properties"]
      },
-      "Event.workspace.ready": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "workspace.ready"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "name": {
-                "type": "string"
-              }
-            },
-            "required": ["name"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.workspace.failed": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "workspace.failed"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "message": {
-                "type": "string"
-              }
-            },
-            "required": ["message"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.workspace.restore": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "workspace.restore"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "workspaceID": {
-                "type": "string",
-                "pattern": "^wrk.*"
-              },
-              "sessionID": {
-                "type": "string",
-                "pattern": "^ses.*"
-              },
-              "total": {
-                "type": "integer",
-                "minimum": 0,
-                "maximum": 9007199254740991
-              },
-              "step": {
-                "type": "integer",
-                "minimum": 0,
-                "maximum": 9007199254740991
-              }
-            },
-            "required": ["workspaceID", "sessionID", "total", "step"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.workspace.status": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "workspace.status"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "workspaceID": {
-                "type": "string",
-                "pattern": "^wrk.*"
-              },
-              "status": {
-                "type": "string",
-                "enum": ["connected", "connecting", "disconnected", "error"]
-              }
-            },
-            "required": ["workspaceID", "status"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
      "Event.worktree.ready": {
        "type": "object",
        "properties": {
@@ -9071,6 +8901,102 @@
        },
        "required": ["type", "properties"]
      },
+      "Event.workspace.ready": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "workspace.ready"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string"
+              }
+            },
+            "required": ["name"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.workspace.failed": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "workspace.failed"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "message": {
+                "type": "string"
+              }
+            },
+            "required": ["message"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.workspace.restore": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "workspace.restore"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "workspaceID": {
+                "type": "string",
+                "pattern": "^wrk.*"
+              },
+              "sessionID": {
+                "type": "string",
+                "pattern": "^ses.*"
+              },
+              "total": {
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 9007199254740991
+              },
+              "step": {
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 9007199254740991
+              }
+            },
+            "required": ["workspaceID", "sessionID", "total", "step"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.workspace.status": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "workspace.status"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "workspaceID": {
+                "type": "string",
+                "pattern": "^wrk.*"
+              },
+              "status": {
+                "type": "string",
+                "enum": ["connected", "connecting", "disconnected", "error"]
+              }
+            },
+            "required": ["workspaceID", "status"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
      "OutputFormatText": {
        "type": "object",
        "properties": {
@@ -10415,7 +10341,9 @@
                "maximum": 9007199254740991
              },
              "archived": {
-                "type": "number"
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 9007199254740991
              }
            },
            "required": ["created", "updated"]
@@ -10926,7 +10854,9 @@
                      "archived": {
                        "anyOf": [
                          {
-                            "type": "number"
+                            "type": "integer",
+                            "minimum": 0,
+                            "maximum": 9007199254740991
                          },
                          {
                            "type": "null"
@@ -11121,18 +11051,6 @@
              {
                "$ref": "#/components/schemas/Event.vcs.branch.updated"
              },
-              {
-                "$ref": "#/components/schemas/Event.workspace.ready"
-              },
-              {
-                "$ref": "#/components/schemas/Event.workspace.failed"
-              },
-              {
-                "$ref": "#/components/schemas/Event.workspace.restore"
-              },
-              {
-                "$ref": "#/components/schemas/Event.workspace.status"
-              },
              {
                "$ref": "#/components/schemas/Event.worktree.ready"
              },
@@ -11151,6 +11069,18 @@
              {
                "$ref": "#/components/schemas/Event.pty.deleted"
              },
+              {
+                "$ref": "#/components/schemas/Event.workspace.ready"
+              },
+              {
+                "$ref": "#/components/schemas/Event.workspace.failed"
+              },
+              {
+                "$ref": "#/components/schemas/Event.workspace.restore"
+              },
+              {
+                "$ref": "#/components/schemas/Event.workspace.status"
+              },
              {
                "$ref": "#/components/schemas/Event.message.updated"
              },
@@ -12843,7 +12773,9 @@
                "maximum": 9007199254740991
              },
              "archived": {
-                "type": "number"
+                "type": "integer",
+                "minimum": 0,
+                "maximum": 9007199254740991
              }
            },
            "required": ["created", "updated"]
@@ -13414,18 +13346,6 @@
          {
            "$ref": "#/components/schemas/Event.vcs.branch.updated"
          },
-          {
-            "$ref": "#/components/schemas/Event.workspace.ready"
-          },
-          {
-            "$ref": "#/components/schemas/Event.workspace.failed"
-          },
-          {
-            "$ref": "#/components/schemas/Event.workspace.restore"
-          },
-          {
-            "$ref": "#/components/schemas/Event.workspace.status"
-          },
          {
            "$ref": "#/components/schemas/Event.worktree.ready"
          },
@@ -13444,6 +13364,18 @@
          {
            "$ref": "#/components/schemas/Event.pty.deleted"
          },
+          {
+            "$ref": "#/components/schemas/Event.workspace.ready"
+          },
+          {
+            "$ref": "#/components/schemas/Event.workspace.failed"
+          },
+          {
+            "$ref": "#/components/schemas/Event.workspace.restore"
+          },
+          {
+            "$ref": "#/components/schemas/Event.workspace.status"
+          },
          {
            "$ref": "#/components/schemas/Event.message.updated"
          },
Author	SHA1	Message	Date
James Long	fdfe599cb5	handle all events	2026-04-30 10:43:06 -04:00
James Long	6df566161e	fix(core): run sessions with the same directory they were created with	2026-04-30 10:43:05 -04:00
				`@@ -1 +0,0 @@`
				ALTER TABLE `event_sequence` ADD `owner_id` text;