test: finish HTTP mock processor coverage

test: migrate processor tests to HTTP mock LLM server
Replace the custom TestLLM Effect service with the real LLM layer + TestLLMServer HTTP mock for 9 of 10 processor tests. Tests now exercise the full HTTP→SSE→AI SDK→processor pipeline. - Export Provider.defaultLayer for test layer composition - Add boot() helper for common service access (processor, session, provider) - Extend TestLLMServer with usage support and httpError step type - Tool abort test registers a real tool with hanging execute - Reasoning test stays with in-process TestLLM (needs fine-grained events)
2026-03-31 20:36:18 -04:00 · 2026-03-31 19:59:56 -04:00 · 2026-03-31 19:21:27 -04:00 · 2026-03-31 17:32:24 -04:00 · 2026-03-31 16:42:20 -04:00 · 2026-03-31 16:42:19 -04:00
84 changed files with 1551 additions and 3204 deletions
@@ -11,7 +11,6 @@ adamdotdevin
 -agusbasari29 AI PR slop
 ariane-emory
 -atharvau AI review spamming literally every PR
-borealbytes
 -danieljoshuanazareth
 -danieljoshuanazareth
 edemaine
@@ -28,4 +27,3 @@ rekram1-node
 -robinmordasiewicz
 -spider-yamet clawdbot/llm psychosis, spam pinging the team
 thdxr
-toastythebot
@@ -26,7 +26,7 @@
    },
    "packages/app": {
      "name": "@opencode-ai/app",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/sdk": "workspace:*",
@@ -79,7 +79,7 @@
    },
    "packages/console/app": {
      "name": "@opencode-ai/console-app",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -113,7 +113,7 @@
    },
    "packages/console/core": {
      "name": "@opencode-ai/console-core",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -140,7 +140,7 @@
    },
    "packages/console/function": {
      "name": "@opencode-ai/console-function",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@ai-sdk/anthropic": "3.0.64",
        "@ai-sdk/openai": "3.0.48",
@@ -164,7 +164,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode-ai/console-mail",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -188,7 +188,7 @@
    },
    "packages/desktop": {
      "name": "@opencode-ai/desktop",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@opencode-ai/app": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -221,7 +221,7 @@
    },
    "packages/desktop-electron": {
      "name": "@opencode-ai/desktop-electron",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@opencode-ai/app": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
@@ -252,7 +252,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode-ai/enterprise",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@opencode-ai/ui": "workspace:*",
        "@opencode-ai/util": "workspace:*",
@@ -281,7 +281,7 @@
    },
    "packages/function": {
      "name": "@opencode-ai/function",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -297,7 +297,7 @@
    },
    "packages/opencode": {
      "name": "opencode",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "bin": {
        "opencode": "./bin/opencode",
      },
@@ -338,8 +338,8 @@
        "@opencode-ai/sdk": "workspace:*",
        "@opencode-ai/util": "workspace:*",
        "@openrouter/ai-sdk-provider": "2.3.3",
-        "@opentui/core": "0.1.95",
-        "@opentui/solid": "0.1.95",
+        "@opentui/core": "0.1.93",
+        "@opentui/solid": "0.1.93",
        "@parcel/watcher": "2.5.1",
        "@pierre/diffs": "catalog:",
        "@solid-primitives/event-bus": "1.1.2",
@@ -423,22 +423,22 @@
    },
    "packages/plugin": {
      "name": "@opencode-ai/plugin",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "zod": "catalog:",
      },
      "devDependencies": {
-        "@opentui/core": "0.1.95",
-        "@opentui/solid": "0.1.95",
+        "@opentui/core": "0.1.93",
+        "@opentui/solid": "0.1.93",
        "@tsconfig/node22": "catalog:",
        "@types/node": "catalog:",
        "@typescript/native-preview": "catalog:",
        "typescript": "catalog:",
      },
      "peerDependencies": {
-        "@opentui/core": ">=0.1.95",
-        "@opentui/solid": ">=0.1.95",
+        "@opentui/core": ">=0.1.93",
+        "@opentui/solid": ">=0.1.93",
      },
      "optionalPeers": [
        "@opentui/core",
@@ -457,7 +457,7 @@
    },
    "packages/sdk/js": {
      "name": "@opencode-ai/sdk",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "devDependencies": {
        "@hey-api/openapi-ts": "0.90.10",
        "@tsconfig/node22": "catalog:",
@@ -468,7 +468,7 @@
    },
    "packages/slack": {
      "name": "@opencode-ai/slack",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@opencode-ai/sdk": "workspace:*",
        "@slack/bolt": "^3.17.1",
@@ -503,7 +503,7 @@
    },
    "packages/ui": {
      "name": "@opencode-ai/ui",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode-ai/sdk": "workspace:*",
@@ -550,7 +550,7 @@
    },
    "packages/util": {
      "name": "@opencode-ai/util",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "zod": "catalog:",
      },
@@ -561,7 +561,7 @@
    },
    "packages/web": {
      "name": "@opencode-ai/web",
-      "version": "1.3.13",
+      "version": "1.3.11",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -612,7 +612,7 @@
  },
  "catalog": {
    "@cloudflare/workers-types": "4.20251008.0",
-    "@effect/platform-node": "4.0.0-beta.43",
+    "@effect/platform-node": "4.0.0-beta.42",
    "@hono/zod-validator": "0.4.2",
    "@kobalte/core": "0.13.11",
    "@octokit/rest": "22.0.0",
@@ -636,7 +636,7 @@
    "dompurify": "3.3.1",
    "drizzle-kit": "1.0.0-beta.19-d95b7a4",
    "drizzle-orm": "1.0.0-beta.19-d95b7a4",
-    "effect": "4.0.0-beta.43",
+    "effect": "4.0.0-beta.42",
    "fuzzysort": "3.1.0",
    "hono": "4.10.7",
    "hono-openapi": "1.1.2",
@@ -995,9 +995,9 @@

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

-    "@effect/platform-node": ["@effect/platform-node@4.0.0-beta.43", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.43", "mime": "^4.1.0", "undici": "^7.24.0" }, "peerDependencies": { "effect": "^4.0.0-beta.43", "ioredis": "^5.7.0" } }, "sha512-Uq6E1rjaIpjHauzjwoB2HzAg3battYt2Boy8XO50GoHiWCXKE6WapYZ0/AnaBx5v5qg2sOfqpuiLsUf9ZgxOkA=="],
+    "@effect/platform-node": ["@effect/platform-node@4.0.0-beta.42", "", { "dependencies": { "@effect/platform-node-shared": "^4.0.0-beta.42", "mime": "^4.1.0", "undici": "^7.24.0" }, "peerDependencies": { "effect": "^4.0.0-beta.42", "ioredis": "^5.7.0" } }, "sha512-kbdRML2FBa4q8U8rZQcnmLKZ5zN/z1bAA7t5D1/UsBHZqJgnfRgu1CP6kaEfb1Nie6YyaWshxTktZQryjvW/Yg=="],

-    "@effect/platform-node-shared": ["@effect/platform-node-shared@4.0.0-beta.43", "", { "dependencies": { "@types/ws": "^8.18.1", "ws": "^8.19.0" }, "peerDependencies": { "effect": "^4.0.0-beta.43" } }, "sha512-A9q0GEb61pYcQ06Dr6gXj1nKlDI3KHsar1sk3qb1ZY+kVSR64tBAylI8zGon23KY+NPtTUj/sEIToB7jc3Qt5w=="],
+    "@effect/platform-node-shared": ["@effect/platform-node-shared@4.0.0-beta.42", "", { "dependencies": { "@types/ws": "^8.18.1", "ws": "^8.19.0" }, "peerDependencies": { "effect": "^4.0.0-beta.42" } }, "sha512-PC+lxLsrwob3+nBChAPrQq32olCeyApgXBvs1NrRsoArLViNT76T/68CttuCAksCZj5e1bZ1ZibLPel3vUmx2g=="],

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

@@ -1461,21 +1461,21 @@

    "@opentelemetry/api": ["@opentelemetry/api@1.9.0", "", {}, "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg=="],

-    "@opentui/core": ["@opentui/core@0.1.95", "", { "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.95", "@opentui/core-darwin-x64": "0.1.95", "@opentui/core-linux-arm64": "0.1.95", "@opentui/core-linux-x64": "0.1.95", "@opentui/core-win32-arm64": "0.1.95", "@opentui/core-win32-x64": "0.1.95", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-Ha73I+PPSy6Jk8CTZgdGRHU+nnmrPAs7m6w0k6ge1/kWbcNcZB0lY67sWQMdoa6bSINQMNWg7SjbNCC9B/0exg=="],
+    "@opentui/core": ["@opentui/core@0.1.93", "", { "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.93", "@opentui/core-darwin-x64": "0.1.93", "@opentui/core-linux-arm64": "0.1.93", "@opentui/core-linux-x64": "0.1.93", "@opentui/core-win32-arm64": "0.1.93", "@opentui/core-win32-x64": "0.1.93", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-HlTM16ZiBKN0mPBNMHSILkSrbzNku6Pg/ovIpVVkEPqLeWeSC2bfZS4Uhc0Ej1sckVVVoU9HKBJanfHvpP+pMg=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.95", "", { "os": "darwin", "cpu": "arm64" }, "sha512-92joqr0ucGaIBCl9uYhe5DwAPbgGMTaCsCeY8Yf3VQ72wjGbOTwnC1TvU5wC6bUmiyqfijCqMyuUnj83teIVVQ=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.93", "", { "os": "darwin", "cpu": "arm64" }, "sha512-4I2mwhXLqRNUv7tu88hA6cBGaGpLZXkAa8W0VqBiGDV+Tx337x4T+vbQ7G57OwKXT787oTrEOF9rOOrGLov6qw=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.95", "", { "os": "darwin", "cpu": "x64" }, "sha512-+TLL3Kp3x7DTWEAkCAYe+RjRhl58QndoeXMstZNS8GQyrjSpUuivzwidzAz0HZK9SbZJfvaxZmXsToAIdI2fag=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.93", "", { "os": "darwin", "cpu": "x64" }, "sha512-jvYMgcg47a5qLhSv1DnQiafEWBQ1UukGutmsYV1TvNuhWtuDXYLVy2AhKIHPzbB9JNrV0IpjbxUC8QnJaP3n8g=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.95", "", { "os": "linux", "cpu": "arm64" }, "sha512-dAYeRqh7P8o0xFZleDDR1Abt4gSvCISqw6syOrbH3dl7pMbVdGgzA5stM9jqMgdPUVE7Ngumo17C23ehkGv93A=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.93", "", { "os": "linux", "cpu": "arm64" }, "sha512-bvFqRcPftmg14iYmMc3d63XC9rhe4yF7pJRApH6klLBKp27WX/LU0iSO4mvyX7qhy65gcmyy4Sj9dl5jNJ+vlA=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.95", "", { "os": "linux", "cpu": "x64" }, "sha512-O54TCgK8E7j2NKrDXUOTZqO4sb8JjeAfnhrStxAMMEw4RFCGWx3p3wLesqR16uKfFFJFDyoh2OWZ698tO88EAA=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.93", "", { "os": "linux", "cpu": "x64" }, "sha512-/wJXhwtNxdcpshrRl1KouyGE54ODAHxRQgBHtnlM/F4bB8cjzOlq2Yc+5cv5DxRz4Q0nQZFCPefwpg2U6ZwNdA=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.95", "", { "os": "win32", "cpu": "arm64" }, "sha512-T1RlZ6U/95eYDN6rUm4SLOVA5LBR7iL3TcBroQhV/883bVczXIBPhriEXQayup5FsAemnQba1BzMNvy6128SUw=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.93", "", { "os": "win32", "cpu": "arm64" }, "sha512-g3PQobfM2yFPSzkBKRKFp8FgTG4ulWyJcU+GYXjyYmxQIT+ZbOU7UfR//ImRq3/FxUAfUC/MhC6WwjqccjEqBw=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.95", "", { "os": "win32", "cpu": "x64" }, "sha512-lH2FHO0HSP2xWT+ccoz0BkLYFsMm7e6OYOh63BUHHh5b7ispnzP4aTyxiaLWrfJwdL0M9rp5cLIY32bhBKF2oA=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.93", "", { "os": "win32", "cpu": "x64" }, "sha512-Spllte2W7q+WfB1zVHgHilVJNp+jpp77PkkxTWyMQNvT7vJNt9LABMNjGTGiJBBMkAuKvO0GgFNKxrda7tFKrQ=="],

-    "@opentui/solid": ["@opentui/solid@0.1.95", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.95", "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-iotYCvULgDurLXv3vgOzTLnEOySHFOa/6cEDex76jBt+gkniOEh2cjxxIVt6lkfTsk6UNTk6yCdwNK3nca/j+Q=="],
+    "@opentui/solid": ["@opentui/solid@0.1.93", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.93", "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-Qx+4qoLSjnRGoo/YY4sZJMyXj09Y5kaAMpVO+65Ax58MMj4TjABN4bOOiRT2KV7sKOMTjxiAgXAIaBuqBBJ0Qg=="],

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

@@ -2771,7 +2771,7 @@

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

-    "effect": ["effect@4.0.0-beta.43", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.5.3", "find-my-way-ts": "^0.1.6", "ini": "^6.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^1.11.8", "multipasta": "^0.2.7", "toml": "^3.0.0", "uuid": "^13.0.0", "yaml": "^2.8.2" } }, "sha512-AJYyDimIwJOn87uUz/JzmgDc5GfjxJbXvEbTvNzMa+M3Uer344bLo/O5mMRkqc1vBleA+Ygs4+dbE3QsqOkKTQ=="],
+    "effect": ["effect@4.0.0-beta.42", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "fast-check": "^4.5.3", "find-my-way-ts": "^0.1.6", "ini": "^6.0.0", "kubernetes-types": "^1.30.0", "msgpackr": "^1.11.8", "multipasta": "^0.2.7", "toml": "^3.0.0", "uuid": "^13.0.0", "yaml": "^2.8.2" } }, "sha512-c1UrRP+tLzyHb4Fepl8XBDJlLQLkrcMXrRBba441GQRxMbeQ/aIOSFcBwSda1iMJ5l9F0lYc3Bhe33/whrmavQ=="],

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

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-bjfe8/aD0hvUQQEfaNdmKV/Y3dzpf8oz1OUJdgf61WI=",
-    "aarch64-linux": "sha256-iU9v+ekSCB/qTUG+pOOpSMhPh+0hWnWU5jzDNllEkxU=",
-    "aarch64-darwin": "sha256-SgNydQLeAjbX0J49f2VKcgKg2Y30pK826R2qQJBMWE4=",
-    "x86_64-darwin": "sha256-/rzwNuI9x55qi0UcU7QvPUTupErmkt62T09g1omXkQk="
+    "x86_64-linux": "sha256-UuVbB5lTRB4bIcaKMc8CLSbQW7m9EjXgxYvxp/uO7Co=",
+    "aarch64-linux": "sha256-8D7ReLRVb7NDd5PQTVxFhRLmlLbfjK007XgIhhpNKoE=",
+    "aarch64-darwin": "sha256-M+z7C/eXfVqwDiGiiwKo/LT/m4dvCjL1Pblsr1kxoyI=",
+    "x86_64-darwin": "sha256-RzZS6GMwYVDPK0W+K/mlebixNMs2+JRkMG9n8OFhd0c="
  }
 }
@@ -25,7 +25,7 @@
      "packages/slack"
    ],
    "catalog": {
-      "@effect/platform-node": "4.0.0-beta.43",
+      "@effect/platform-node": "4.0.0-beta.42",
      "@types/bun": "1.3.11",
      "@octokit/rest": "22.0.0",
      "@hono/zod-validator": "0.4.2",
@@ -45,7 +45,7 @@
      "dompurify": "3.3.1",
      "drizzle-kit": "1.0.0-beta.19-d95b7a4",
      "drizzle-orm": "1.0.0-beta.19-d95b7a4",
-      "effect": "4.0.0-beta.43",
+      "effect": "4.0.0-beta.42",
      "ai": "6.0.138",
      "hono": "4.10.7",
      "hono-openapi": "1.1.2",
@@ -312,11 +312,10 @@ export async function openSettings(page: Page) {
  return dialog
 }

-export async function seedProjects(page: Page, input: { directory: string; extra?: string[]; serverUrl?: string }) {
+export async function seedProjects(page: Page, input: { directory: string; extra?: string[] }) {
  await page.addInitScript(
    (args: { directory: string; serverUrl: string; extra: string[] }) => {
      const key = "opencode.global.dat:server"
-      const defaultKey = "opencode.settings.dat:defaultServerUrl"
      const raw = localStorage.getItem(key)
      const parsed = (() => {
        if (!raw) return undefined
@@ -332,7 +331,6 @@ export async function seedProjects(page: Page, input: { directory: string; extra
      const lastProject = store.lastProject && typeof store.lastProject === "object" ? store.lastProject : {}
      const projects = store.projects && typeof store.projects === "object" ? store.projects : {}
      const nextProjects = { ...(projects as Record<string, unknown>) }
-      const nextList = list.includes(args.serverUrl) ? list : [args.serverUrl, ...list]

      const add = (origin: string, directory: string) => {
        const current = nextProjects[origin]
@@ -358,18 +356,17 @@ export async function seedProjects(page: Page, input: { directory: string; extra
      localStorage.setItem(
        key,
        JSON.stringify({
-          list: nextList,
+          list,
          projects: nextProjects,
          lastProject,
        }),
      )
-      localStorage.setItem(defaultKey, args.serverUrl)
    },
-    { directory: input.directory, serverUrl: input.serverUrl ?? serverUrl, extra: input.extra ?? [] },
+    { directory: input.directory, serverUrl, extra: input.extra ?? [] },
  )
 }

-export async function createTestProject(input?: { serverUrl?: string }) {
+export async function createTestProject() {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-"))
  const id = `e2e-${path.basename(root)}`

@@ -384,7 +381,7 @@ export async function createTestProject(input?: { serverUrl?: string }) {
    stdio: "ignore",
  })

-  return resolveDirectory(root, input?.serverUrl)
+  return resolveDirectory(root)
 }

 export async function cleanupTestProject(directory: string) {
@@ -433,22 +430,22 @@ export async function waitSlug(page: Page, skip: string[] = []) {
  return next
 }

-export async function resolveSlug(slug: string, input?: { serverUrl?: string }) {
+export async function resolveSlug(slug: string) {
  const directory = base64Decode(slug)
  if (!directory) throw new Error(`Failed to decode workspace slug: ${slug}`)
-  const resolved = await resolveDirectory(directory, input?.serverUrl)
+  const resolved = await resolveDirectory(directory)
  return { directory: resolved, slug: base64Encode(resolved), raw: slug }
 }

-export async function waitDir(page: Page, directory: string, input?: { serverUrl?: string }) {
-  const target = await resolveDirectory(directory, input?.serverUrl)
+export async function waitDir(page: Page, directory: string) {
+  const target = await resolveDirectory(directory)
  await expect
    .poll(
      async () => {
        await assertHealthy(page, "waitDir")
        const slug = slugFromUrl(page.url())
        if (!slug) return ""
-        return resolveSlug(slug, input)
+        return resolveSlug(slug)
          .then((item) => item.directory)
          .catch(() => "")
      },
@@ -458,15 +455,15 @@ export async function waitDir(page: Page, directory: string, input?: { serverUrl
  return { directory: target, slug: base64Encode(target) }
 }

-export async function waitSession(page: Page, input: { directory: string; sessionID?: string; serverUrl?: string }) {
-  const target = await resolveDirectory(input.directory, input.serverUrl)
+export async function waitSession(page: Page, input: { directory: string; sessionID?: string }) {
+  const target = await resolveDirectory(input.directory)
  await expect
    .poll(
      async () => {
        await assertHealthy(page, "waitSession")
        const slug = slugFromUrl(page.url())
        if (!slug) return false
-        const resolved = await resolveSlug(slug, { serverUrl: input.serverUrl }).catch(() => undefined)
+        const resolved = await resolveSlug(slug).catch(() => undefined)
        if (!resolved || resolved.directory !== target) return false
        const current = sessionIDFromUrl(page.url())
        if (input.sessionID && current !== input.sessionID) return false
@@ -476,7 +473,7 @@ export async function waitSession(page: Page, input: { directory: string; sessio
        if (input.sessionID && (!state || state.sessionID !== input.sessionID)) return false
        if (!input.sessionID && state?.sessionID) return false
        if (state?.dir) {
-          const dir = await resolveDirectory(state.dir, input.serverUrl).catch(() => state.dir ?? "")
+          const dir = await resolveDirectory(state.dir).catch(() => state.dir ?? "")
          if (dir !== target) return false
        }

@@ -492,9 +489,9 @@ export async function waitSession(page: Page, input: { directory: string; sessio
  return { directory: target, slug: base64Encode(target) }
 }

-export async function waitSessionSaved(directory: string, sessionID: string, timeout = 30_000, serverUrl?: string) {
-  const sdk = createSdk(directory, serverUrl)
-  const target = await resolveDirectory(directory, serverUrl)
+export async function waitSessionSaved(directory: string, sessionID: string, timeout = 30_000) {
+  const sdk = createSdk(directory)
+  const target = await resolveDirectory(directory)

  await expect
    .poll(
@@ -504,7 +501,7 @@ export async function waitSessionSaved(directory: string, sessionID: string, tim
          .then((x) => x.data)
          .catch(() => undefined)
        if (!data?.directory) return ""
-        return resolveDirectory(data.directory, serverUrl).catch(() => data.directory)
+        return resolveDirectory(data.directory).catch(() => data.directory)
      },
      { timeout },
    )
@@ -669,9 +666,8 @@ export async function cleanupSession(input: {
  sessionID: string
  directory?: string
  sdk?: ReturnType<typeof createSdk>
-  serverUrl?: string
 }) {
-  const sdk = input.sdk ?? (input.directory ? createSdk(input.directory, input.serverUrl) : undefined)
+  const sdk = input.sdk ?? (input.directory ? createSdk(input.directory) : undefined)
  if (!sdk) throw new Error("cleanupSession requires sdk or directory")
  await waitSessionIdle(sdk, input.sessionID, 5_000).catch(() => undefined)
  const current = await status(sdk, input.sessionID).catch(() => undefined)
@@ -1023,13 +1019,3 @@ export async function openWorkspaceMenu(page: Page, workspaceSlug: string) {
  await expect(menu).toBeVisible()
  return menu
 }
-
-export async function assistantText(sdk: ReturnType<typeof createSdk>, sessionID: string) {
-  const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
-  return messages
-    .filter((m) => m.info.role === "assistant")
-    .flatMap((m) => m.parts)
-    .filter((p) => p.type === "text")
-    .map((p) => p.text)
-    .join("\n")
-}
@@ -1,125 +0,0 @@
-import { spawn } from "node:child_process"
-import fs from "node:fs/promises"
-import net from "node:net"
-import os from "node:os"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-type Handle = {
-  url: string
-  stop: () => Promise<void>
-}
-
-function freePort() {
-  return new Promise<number>((resolve, reject) => {
-    const server = net.createServer()
-    server.once("error", reject)
-    server.listen(0, () => {
-      const address = server.address()
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("Failed to acquire a free port")))
-        return
-      }
-      server.close((err) => {
-        if (err) reject(err)
-        else resolve(address.port)
-      })
-    })
-  })
-}
-
-async function waitForHealth(url: string, probe = "/global/health") {
-  const end = Date.now() + 120_000
-  let last = ""
-  while (Date.now() < end) {
-    try {
-      const res = await fetch(`${url}${probe}`)
-      if (res.ok) return
-      last = `status ${res.status}`
-    } catch (err) {
-      last = err instanceof Error ? err.message : String(err)
-    }
-    await new Promise((resolve) => setTimeout(resolve, 250))
-  }
-  throw new Error(`Timed out waiting for backend health at ${url}${probe}${last ? ` (${last})` : ""}`)
-}
-
-const LOG_CAP = 100
-
-function cap(input: string[]) {
-  if (input.length > LOG_CAP) input.splice(0, input.length - LOG_CAP)
-}
-
-function tail(input: string[]) {
-  return input.slice(-40).join("")
-}
-
-export async function startBackend(label: string): Promise<Handle> {
-  const port = await freePort()
-  const sandbox = await fs.mkdtemp(path.join(os.tmpdir(), `opencode-e2e-${label}-`))
-  const appDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
-  const repoDir = path.resolve(appDir, "../..")
-  const opencodeDir = path.join(repoDir, "packages", "opencode")
-  const env = {
-    ...process.env,
-    OPENCODE_DISABLE_SHARE: process.env.OPENCODE_DISABLE_SHARE ?? "true",
-    OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
-    OPENCODE_DISABLE_DEFAULT_PLUGINS: "true",
-    OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "true",
-    OPENCODE_TEST_HOME: path.join(sandbox, "home"),
-    XDG_DATA_HOME: path.join(sandbox, "share"),
-    XDG_CACHE_HOME: path.join(sandbox, "cache"),
-    XDG_CONFIG_HOME: path.join(sandbox, "config"),
-    XDG_STATE_HOME: path.join(sandbox, "state"),
-    OPENCODE_CLIENT: "app",
-    OPENCODE_STRICT_CONFIG_DEPS: "true",
-  } satisfies Record<string, string | undefined>
-  const out: string[] = []
-  const err: string[] = []
-  const proc = spawn(
-    "bun",
-    ["run", "--conditions=browser", "./src/index.ts", "serve", "--port", String(port), "--hostname", "127.0.0.1"],
-    {
-      cwd: opencodeDir,
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-    },
-  )
-  proc.stdout?.on("data", (chunk) => {
-    out.push(String(chunk))
-    cap(out)
-  })
-  proc.stderr?.on("data", (chunk) => {
-    err.push(String(chunk))
-    cap(err)
-  })
-
-  const url = `http://127.0.0.1:${port}`
-  try {
-    await waitForHealth(url)
-  } catch (error) {
-    proc.kill("SIGTERM")
-    await fs.rm(sandbox, { recursive: true, force: true }).catch(() => undefined)
-    throw new Error(
-      [
-        `Failed to start isolated e2e backend for ${label}`,
-        error instanceof Error ? error.message : String(error),
-        tail(out),
-        tail(err),
-      ]
-        .filter(Boolean)
-        .join("\n"),
-    )
-  }
-
-  return {
-    url,
-    async stop() {
-      if (proc.exitCode === null) {
-        proc.kill("SIGTERM")
-        await new Promise((resolve) => proc.once("exit", () => resolve(undefined))).catch(() => undefined)
-      }
-      await fs.rm(sandbox, { recursive: true, force: true }).catch(() => undefined)
-    },
-  }
-}
@@ -1,9 +1,5 @@
 import { test as base, expect, type Page } from "@playwright/test"
-import { ManagedRuntime } from "effect"
 import type { E2EWindow } from "../src/testing/terminal"
-import type { Item, Reply, Usage } from "../../opencode/test/lib/llm-server"
-import { TestLLMServer } from "../../opencode/test/lib/llm-server"
-import { startBackend } from "./backend"
 import {
  healthPhase,
  cleanupSession,
@@ -17,38 +13,6 @@ import {
 } from "./actions"
 import { createSdk, dirSlug, getWorktree, sessionPath } from "./utils"

-type LLMFixture = {
-  url: string
-  push: (...input: (Item | Reply)[]) => Promise<void>
-  pushMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    ...input: (Item | Reply)[]
-  ) => Promise<void>
-  textMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    value: string,
-    opts?: { usage?: Usage },
-  ) => Promise<void>
-  toolMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    name: string,
-    input: unknown,
-  ) => Promise<void>
-  text: (value: string, opts?: { usage?: Usage }) => Promise<void>
-  tool: (name: string, input: unknown) => Promise<void>
-  toolHang: (name: string, input: unknown) => Promise<void>
-  reason: (value: string, opts?: { text?: string; usage?: Usage }) => Promise<void>
-  fail: (message?: unknown) => Promise<void>
-  error: (status: number, body: unknown) => Promise<void>
-  hang: () => Promise<void>
-  hold: (value: string, wait: PromiseLike<unknown>) => Promise<void>
-  hits: () => Promise<Array<{ url: URL; body: Record<string, unknown> }>>
-  calls: () => Promise<number>
-  wait: (count: number) => Promise<void>
-  inputs: () => Promise<Record<string, unknown>[]>
-  pending: () => Promise<number>
-}
-
 export const settingsKey = "settings.v3"

 const seedModel = (() => {
@@ -61,82 +25,27 @@ const seedModel = (() => {
  }
 })()

-type ProjectHandle = {
-  directory: string
-  slug: string
-  gotoSession: (sessionID?: string) => Promise<void>
-  trackSession: (sessionID: string, directory?: string) => void
-  trackDirectory: (directory: string) => void
-  sdk: ReturnType<typeof createSdk>
-}
-
-type ProjectOptions = {
-  extra?: string[]
-  model?: { providerID: string; modelID: string }
-  setup?: (directory: string) => Promise<void>
-  beforeGoto?: (project: { directory: string; sdk: ReturnType<typeof createSdk> }) => Promise<void>
-}
-
 type TestFixtures = {
-  llm: LLMFixture
  sdk: ReturnType<typeof createSdk>
  gotoSession: (sessionID?: string) => Promise<void>
-  withProject: <T>(callback: (project: ProjectHandle) => Promise<T>, options?: ProjectOptions) => Promise<T>
-  withBackendProject: <T>(callback: (project: ProjectHandle) => Promise<T>, options?: ProjectOptions) => Promise<T>
+  withProject: <T>(
+    callback: (project: {
+      directory: string
+      slug: string
+      gotoSession: (sessionID?: string) => Promise<void>
+      trackSession: (sessionID: string, directory?: string) => void
+      trackDirectory: (directory: string) => void
+    }) => Promise<T>,
+    options?: { extra?: string[] },
+  ) => Promise<T>
 }

 type WorkerFixtures = {
-  backend: {
-    url: string
-    sdk: (directory?: string) => ReturnType<typeof createSdk>
-  }
  directory: string
  slug: string
 }

 export const test = base.extend<TestFixtures, WorkerFixtures>({
-  backend: [
-    async ({}, use, workerInfo) => {
-      const handle = await startBackend(`w${workerInfo.workerIndex}`)
-      try {
-        await use({
-          url: handle.url,
-          sdk: (directory?: string) => createSdk(directory, handle.url),
-        })
-      } finally {
-        await handle.stop()
-      }
-    },
-    { scope: "worker" },
-  ],
-  llm: async ({}, use) => {
-    const rt = ManagedRuntime.make(TestLLMServer.layer)
-    try {
-      const svc = await rt.runPromise(TestLLMServer.asEffect())
-      await use({
-        url: svc.url,
-        push: (...input) => rt.runPromise(svc.push(...input)),
-        pushMatch: (match, ...input) => rt.runPromise(svc.pushMatch(match, ...input)),
-        textMatch: (match, value, opts) => rt.runPromise(svc.textMatch(match, value, opts)),
-        toolMatch: (match, name, input) => rt.runPromise(svc.toolMatch(match, name, input)),
-        text: (value, opts) => rt.runPromise(svc.text(value, opts)),
-        tool: (name, input) => rt.runPromise(svc.tool(name, input)),
-        toolHang: (name, input) => rt.runPromise(svc.toolHang(name, input)),
-        reason: (value, opts) => rt.runPromise(svc.reason(value, opts)),
-        fail: (message) => rt.runPromise(svc.fail(message)),
-        error: (status, body) => rt.runPromise(svc.error(status, body)),
-        hang: () => rt.runPromise(svc.hang),
-        hold: (value, wait) => rt.runPromise(svc.hold(value, wait)),
-        hits: () => rt.runPromise(svc.hits),
-        calls: () => rt.runPromise(svc.calls),
-        wait: (count) => rt.runPromise(svc.wait(count)),
-        inputs: () => rt.runPromise(svc.inputs),
-        pending: () => rt.runPromise(svc.pending),
-      })
-    } finally {
-      await rt.dispose()
-    }
-  },
  page: async ({ page }, use) => {
    let boundary: string | undefined
    setHealthPhase(page, "test")
@@ -186,76 +95,45 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
    await use(gotoSession)
  },
  withProject: async ({ page }, use) => {
-    await use((callback, options) => runProject(page, callback, options))
-  },
-  withBackendProject: async ({ page, backend }, use) => {
-    await use((callback, options) =>
-      runProject(page, callback, { ...options, serverUrl: backend.url, sdk: backend.sdk }),
-    )
+    await use(async (callback, options) => {
+      const root = await createTestProject()
+      const sessions = new Map<string, string>()
+      const dirs = new Set<string>()
+      await seedStorage(page, { directory: root, extra: options?.extra })
+
+      const gotoSession = async (sessionID?: string) => {
+        await page.goto(sessionPath(root, sessionID))
+        await waitSession(page, { directory: root, sessionID })
+        const current = sessionIDFromUrl(page.url())
+        if (current) trackSession(current)
+      }
+
+      const trackSession = (sessionID: string, directory?: string) => {
+        sessions.set(sessionID, directory ?? root)
+      }
+
+      const trackDirectory = (directory: string) => {
+        if (directory !== root) dirs.add(directory)
+      }
+
+      try {
+        await gotoSession()
+        const slug = await waitSlug(page)
+        return await callback({ directory: root, slug, gotoSession, trackSession, trackDirectory })
+      } finally {
+        setHealthPhase(page, "cleanup")
+        await Promise.allSettled(
+          Array.from(sessions, ([sessionID, directory]) => cleanupSession({ sessionID, directory })),
+        )
+        await Promise.allSettled(Array.from(dirs, (directory) => cleanupTestProject(directory)))
+        await cleanupTestProject(root)
+        setHealthPhase(page, "test")
+      }
+    })
  },
 })

-async function runProject<T>(
-  page: Page,
-  callback: (project: ProjectHandle) => Promise<T>,
-  options?: ProjectOptions & {
-    serverUrl?: string
-    sdk?: (directory?: string) => ReturnType<typeof createSdk>
-  },
-) {
-  const url = options?.serverUrl
-  const root = await createTestProject(url ? { serverUrl: url } : undefined)
-  const sdk = options?.sdk?.(root) ?? createSdk(root, url)
-  const sessions = new Map<string, string>()
-  const dirs = new Set<string>()
-  await options?.setup?.(root)
-  await seedStorage(page, {
-    directory: root,
-    extra: options?.extra,
-    model: options?.model,
-    serverUrl: url,
-  })
-
-  const gotoSession = async (sessionID?: string) => {
-    await page.goto(sessionPath(root, sessionID))
-    await waitSession(page, { directory: root, sessionID, serverUrl: url })
-    const current = sessionIDFromUrl(page.url())
-    if (current) trackSession(current)
-  }
-
-  const trackSession = (sessionID: string, directory?: string) => {
-    sessions.set(sessionID, directory ?? root)
-  }
-
-  const trackDirectory = (directory: string) => {
-    if (directory !== root) dirs.add(directory)
-  }
-
-  try {
-    await options?.beforeGoto?.({ directory: root, sdk })
-    await gotoSession()
-    const slug = await waitSlug(page)
-    return await callback({ directory: root, slug, gotoSession, trackSession, trackDirectory, sdk })
-  } finally {
-    setHealthPhase(page, "cleanup")
-    await Promise.allSettled(
-      Array.from(sessions, ([sessionID, directory]) => cleanupSession({ sessionID, directory, serverUrl: url })),
-    )
-    await Promise.allSettled(Array.from(dirs, (directory) => cleanupTestProject(directory)))
-    await cleanupTestProject(root)
-    setHealthPhase(page, "test")
-  }
-}
-
-async function seedStorage(
-  page: Page,
-  input: {
-    directory: string
-    extra?: string[]
-    model?: { providerID: string; modelID: string }
-    serverUrl?: string
-  },
-) {
+async function seedStorage(page: Page, input: { directory: string; extra?: string[] }) {
  await seedProjects(page, input)
  await page.addInitScript((model: { providerID: string; modelID: string }) => {
    const win = window as E2EWindow
@@ -280,7 +158,7 @@ async function seedStorage(
        variant: {},
      }),
    )
-  }, input.model ?? seedModel)
+  }, seedModel)
 }

 export { expect }
@@ -1,46 +0,0 @@
-import { createSdk } from "../utils"
-
-export const openaiModel = { providerID: "openai", modelID: "gpt-5.3-chat-latest" }
-
-type Hit = { body: Record<string, unknown> }
-
-export function bodyText(hit: Hit) {
-  return JSON.stringify(hit.body)
-}
-
-export function titleMatch(hit: Hit) {
-  return bodyText(hit).includes("Generate a title for this conversation")
-}
-
-export function promptMatch(token: string) {
-  return (hit: Hit) => bodyText(hit).includes(token)
-}
-
-export async function withMockOpenAI<T>(input: { serverUrl: string; llmUrl: string; fn: () => Promise<T> }) {
-  const sdk = createSdk(undefined, input.serverUrl)
-  const prev = await sdk.global.config.get().then((res) => res.data ?? {})
-
-  try {
-    await sdk.global.config.update({
-      config: {
-        ...prev,
-        model: `${openaiModel.providerID}/${openaiModel.modelID}`,
-        enabled_providers: ["openai"],
-        provider: {
-          ...prev.provider,
-          openai: {
-            ...prev.provider?.openai,
-            options: {
-              ...prev.provider?.openai?.options,
-              apiKey: "test-key",
-              baseURL: input.llmUrl,
-            },
-          },
-        },
-      },
-    })
-    return await input.fn()
-  } finally {
-    await sdk.global.config.update({ config: prev })
-  }
-}
@@ -1,52 +1,47 @@
 import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
-import { assistantText, sessionIDFromUrl, withSession } from "../actions"
-import { openaiModel, promptMatch, titleMatch, withMockOpenAI } from "./mock"
+import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"

 const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()

 // Regression test for Issue #12453: the synchronous POST /message endpoint holds
 // the connection open while the agent works, causing "Failed to fetch" over
 // VPN/Tailscale. The fix switches to POST /prompt_async which returns immediately.
-test("prompt succeeds when sync message endpoint is unreachable", async ({
-  page,
-  llm,
-  backend,
-  withBackendProject,
-}) => {
+test("prompt succeeds when sync message endpoint is unreachable", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)

  // Simulate Tailscale/VPN killing the long-lived sync connection
  await page.route("**/session/*/message", (route) => route.abort("connectionfailed"))

-  await withMockOpenAI({
-    serverUrl: backend.url,
-    llmUrl: llm.url,
-    fn: async () => {
-      const token = `E2E_ASYNC_${Date.now()}`
-      await llm.textMatch(titleMatch, "E2E Title")
-      await llm.textMatch(promptMatch(token), token)
+  await gotoSession()

-      await withBackendProject(
-        async (project) => {
-          await page.locator(promptSelector).click()
-          await page.keyboard.type(`Reply with exactly: ${token}`)
-          await page.keyboard.press("Enter")
+  const token = `E2E_ASYNC_${Date.now()}`
+  await page.locator(promptSelector).click()
+  await page.keyboard.type(`Reply with exactly: ${token}`)
+  await page.keyboard.press("Enter")

-          await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-          const sessionID = sessionIDFromUrl(page.url())!
-          project.trackSession(sessionID)
+  await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
+  const sessionID = sessionIDFromUrl(page.url())!

-          await expect.poll(() => llm.calls()).toBeGreaterThanOrEqual(1)
-
-          await expect.poll(() => assistantText(project.sdk, sessionID), { timeout: 90_000 }).toContain(token)
-        },
-        {
-          model: openaiModel,
+  try {
+    // Agent response arrives via SSE despite sync endpoint being dead
+    await expect
+      .poll(
+        async () => {
+          const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
+          return messages
+            .filter((m) => m.info.role === "assistant")
+            .flatMap((m) => m.parts)
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n")
        },
+        { timeout: 90_000 },
      )
-    },
-  })
+      .toContain(token)
+  } finally {
+    await cleanupSession({ sdk, sessionID })
+  }
 })

 test("failed prompt send restores the composer input", async ({ page, sdk, gotoSession }) => {
@@ -1,9 +1,8 @@
 import type { ToolPart } from "@opencode-ai/sdk/v2/client"
 import type { Page } from "@playwright/test"
 import { test, expect } from "../fixtures"
-import { assistantText, sessionIDFromUrl } from "../actions"
+import { withSession } from "../actions"
 import { promptSelector } from "../selectors"
-import { openaiModel, promptMatch, titleMatch, withMockOpenAI } from "./mock"

 const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()

@@ -44,13 +43,20 @@ async function wait(page: Page, value: string) {
  await expect.poll(async () => text(await page.locator(promptSelector).textContent())).toBe(value)
 }

-async function reply(
-  sdk: { session: { messages: Parameters<typeof assistantText>[0]["session"] } },
-  sessionID: string,
-  token: string,
-) {
+async function reply(sdk: Parameters<typeof withSession>[0], sessionID: string, token: string) {
  await expect
-    .poll(() => assistantText(sdk as Parameters<typeof assistantText>[0], sessionID), { timeout: 90_000 })
+    .poll(
+      async () => {
+        const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
+        return messages
+          .filter((item) => item.info.role === "assistant")
+          .flatMap((item) => item.parts)
+          .filter((item) => item.type === "text")
+          .map((item) => item.text)
+          .join("\n")
+      },
+      { timeout: 90_000 },
+    )
    .toContain(token)
 }

@@ -73,145 +79,106 @@ async function shell(sdk: Parameters<typeof withSession>[0], sessionID: string,
    .toContain(token)
 }

-test("prompt history restores unsent draft with arrow navigation", async ({
-  page,
-  llm,
-  backend,
-  withBackendProject,
-}) => {
+test("prompt history restores unsent draft with arrow navigation", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)

-  await withMockOpenAI({
-    serverUrl: backend.url,
-    llmUrl: llm.url,
-    fn: async () => {
-      const firstToken = `E2E_HISTORY_ONE_${Date.now()}`
-      const secondToken = `E2E_HISTORY_TWO_${Date.now()}`
-      const first = `Reply with exactly: ${firstToken}`
-      const second = `Reply with exactly: ${secondToken}`
-      const draft = `draft ${Date.now()}`
+  await withSession(sdk, `e2e prompt history ${Date.now()}`, async (session) => {
+    await gotoSession(session.id)

-      await llm.textMatch(titleMatch, "E2E Title")
-      await llm.textMatch(promptMatch(firstToken), firstToken)
-      await llm.textMatch(promptMatch(secondToken), secondToken)
+    const prompt = page.locator(promptSelector)
+    const firstToken = `E2E_HISTORY_ONE_${Date.now()}`
+    const secondToken = `E2E_HISTORY_TWO_${Date.now()}`
+    const first = `Reply with exactly: ${firstToken}`
+    const second = `Reply with exactly: ${secondToken}`
+    const draft = `draft ${Date.now()}`

-      await withBackendProject(
-        async (project) => {
-          const prompt = page.locator(promptSelector)
+    await prompt.click()
+    await page.keyboard.type(first)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await reply(sdk, session.id, firstToken)

-          await prompt.click()
-          await page.keyboard.type(first)
-          await page.keyboard.press("Enter")
-          await wait(page, "")
+    await prompt.click()
+    await page.keyboard.type(second)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await reply(sdk, session.id, secondToken)

-          await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-          const sessionID = sessionIDFromUrl(page.url())!
-          project.trackSession(sessionID)
-          await reply(project.sdk, sessionID, firstToken)
+    await prompt.click()
+    await page.keyboard.type(draft)
+    await wait(page, draft)

-          await prompt.click()
-          await page.keyboard.type(second)
-          await page.keyboard.press("Enter")
-          await wait(page, "")
-          await reply(project.sdk, sessionID, secondToken)
+    // Clear the draft before navigating history (ArrowUp only works when prompt is empty)
+    await prompt.fill("")
+    await wait(page, "")

-          await prompt.click()
-          await page.keyboard.type(draft)
-          await wait(page, draft)
+    await page.keyboard.press("ArrowUp")
+    await wait(page, second)

-          await prompt.fill("")
-          await wait(page, "")
+    await page.keyboard.press("ArrowUp")
+    await wait(page, first)

-          await page.keyboard.press("ArrowUp")
-          await wait(page, second)
+    await page.keyboard.press("ArrowDown")
+    await wait(page, second)

-          await page.keyboard.press("ArrowUp")
-          await wait(page, first)
-
-          await page.keyboard.press("ArrowDown")
-          await wait(page, second)
-
-          await page.keyboard.press("ArrowDown")
-          await wait(page, "")
-        },
-        {
-          model: openaiModel,
-        },
-      )
-    },
+    await page.keyboard.press("ArrowDown")
+    await wait(page, "")
  })
 })

-test("shell history stays separate from normal prompt history", async ({ page, llm, backend, withBackendProject }) => {
+test("shell history stays separate from normal prompt history", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)

-  await withMockOpenAI({
-    serverUrl: backend.url,
-    llmUrl: llm.url,
-    fn: async () => {
-      const firstToken = `E2E_SHELL_ONE_${Date.now()}`
-      const secondToken = `E2E_SHELL_TWO_${Date.now()}`
-      const normalToken = `E2E_NORMAL_${Date.now()}`
-      const first = `echo ${firstToken}`
-      const second = `echo ${secondToken}`
-      const normal = `Reply with exactly: ${normalToken}`
+  await withSession(sdk, `e2e shell history ${Date.now()}`, async (session) => {
+    await gotoSession(session.id)

-      await llm.textMatch(titleMatch, "E2E Title")
-      await llm.textMatch(promptMatch(normalToken), normalToken)
+    const prompt = page.locator(promptSelector)
+    const firstToken = `E2E_SHELL_ONE_${Date.now()}`
+    const secondToken = `E2E_SHELL_TWO_${Date.now()}`
+    const normalToken = `E2E_NORMAL_${Date.now()}`
+    const first = `echo ${firstToken}`
+    const second = `echo ${secondToken}`
+    const normal = `Reply with exactly: ${normalToken}`

-      await withBackendProject(
-        async (project) => {
-          const prompt = page.locator(promptSelector)
+    await prompt.click()
+    await page.keyboard.type("!")
+    await page.keyboard.type(first)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await shell(sdk, session.id, first, firstToken)

-          await prompt.click()
-          await page.keyboard.type("!")
-          await page.keyboard.type(first)
-          await page.keyboard.press("Enter")
-          await wait(page, "")
+    await prompt.click()
+    await page.keyboard.type("!")
+    await page.keyboard.type(second)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await shell(sdk, session.id, second, secondToken)

-          await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-          const sessionID = sessionIDFromUrl(page.url())!
-          project.trackSession(sessionID)
-          await shell(project.sdk, sessionID, first, firstToken)
+    await prompt.click()
+    await page.keyboard.type("!")
+    await page.keyboard.press("ArrowUp")
+    await wait(page, second)

-          await prompt.click()
-          await page.keyboard.type("!")
-          await page.keyboard.type(second)
-          await page.keyboard.press("Enter")
-          await wait(page, "")
-          await shell(project.sdk, sessionID, second, secondToken)
+    await page.keyboard.press("ArrowUp")
+    await wait(page, first)

-          await prompt.click()
-          await page.keyboard.type("!")
-          await page.keyboard.press("ArrowUp")
-          await wait(page, second)
+    await page.keyboard.press("ArrowDown")
+    await wait(page, second)

-          await page.keyboard.press("ArrowUp")
-          await wait(page, first)
+    await page.keyboard.press("ArrowDown")
+    await wait(page, "")

-          await page.keyboard.press("ArrowDown")
-          await wait(page, second)
+    await page.keyboard.press("Escape")
+    await wait(page, "")

-          await page.keyboard.press("ArrowDown")
-          await wait(page, "")
+    await prompt.click()
+    await page.keyboard.type(normal)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await reply(sdk, session.id, normalToken)

-          await page.keyboard.press("Escape")
-          await wait(page, "")
-
-          await prompt.click()
-          await page.keyboard.type(normal)
-          await page.keyboard.press("Enter")
-          await wait(page, "")
-          await reply(project.sdk, sessionID, normalToken)
-
-          await prompt.click()
-          await page.keyboard.press("ArrowUp")
-          await wait(page, normal)
-        },
-        {
-          model: openaiModel,
-        },
-      )
-    },
+    await prompt.click()
+    await page.keyboard.press("ArrowUp")
+    await wait(page, normal)
  })
 })
@@ -2,6 +2,7 @@ import type { ToolPart } from "@opencode-ai/sdk/v2/client"
 import { test, expect } from "../fixtures"
 import { sessionIDFromUrl } from "../actions"
 import { promptSelector } from "../selectors"
+import { createSdk } from "../utils"

 const isBash = (part: unknown): part is ToolPart => {
  if (!part || typeof part !== "object") return false
@@ -10,12 +11,13 @@ const isBash = (part: unknown): part is ToolPart => {
  return "state" in part
 }

-test("shell mode runs a command in the project directory", async ({ page, withBackendProject }) => {
+test("shell mode runs a command in the project directory", async ({ page, withProject }) => {
  test.setTimeout(120_000)

-  await withBackendProject(async ({ directory, gotoSession, trackSession, sdk }) => {
+  await withProject(async ({ directory, gotoSession, trackSession }) => {
+    const sdk = createSdk(directory)
    const prompt = page.locator(promptSelector)
-    const cmd = process.platform === "win32" ? "dir" : "command ls"
+    const cmd = process.platform === "win32" ? "dir" : "ls"

    await gotoSession()
    await prompt.click()
@@ -22,45 +22,43 @@ async function seed(sdk: Parameters<typeof withSession>[0], sessionID: string) {
    .toBeGreaterThan(0)
 }

-test("/share and /unshare update session share state", async ({ page, withBackendProject }) => {
+test("/share and /unshare update session share state", async ({ page, sdk, gotoSession }) => {
  test.skip(shareDisabled, "Share is disabled in this environment (OPENCODE_DISABLE_SHARE).")

-  await withBackendProject(async (project) => {
-    await withSession(project.sdk, `e2e slash share ${Date.now()}`, async (session) => {
-      const prompt = page.locator(promptSelector)
+  await withSession(sdk, `e2e slash share ${Date.now()}`, async (session) => {
+    const prompt = page.locator(promptSelector)

-      await seed(project.sdk, session.id)
-      await project.gotoSession(session.id)
+    await seed(sdk, session.id)
+    await gotoSession(session.id)

-      await prompt.click()
-      await page.keyboard.type("/share")
-      await expect(page.locator('[data-slash-id="session.share"]').first()).toBeVisible()
-      await page.keyboard.press("Enter")
+    await prompt.click()
+    await page.keyboard.type("/share")
+    await expect(page.locator('[data-slash-id="session.share"]').first()).toBeVisible()
+    await page.keyboard.press("Enter")

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.share?.url || undefined
-          },
-          { timeout: 30_000 },
-        )
-        .not.toBeUndefined()
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .not.toBeUndefined()

-      await prompt.click()
-      await page.keyboard.type("/unshare")
-      await expect(page.locator('[data-slash-id="session.unshare"]').first()).toBeVisible()
-      await page.keyboard.press("Enter")
+    await prompt.click()
+    await page.keyboard.type("/unshare")
+    await expect(page.locator('[data-slash-id="session.unshare"]').first()).toBeVisible()
+    await page.keyboard.press("Enter")

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.share?.url || undefined
-          },
-          { timeout: 30_000 },
-        )
-        .toBeUndefined()
-    })
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .toBeUndefined()
  })
 })
@@ -1,9 +1,8 @@
 import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
-import { assistantText, sessionIDFromUrl } from "../actions"
-import { openaiModel, promptMatch, titleMatch, withMockOpenAI } from "./mock"
+import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"

-test("can send a prompt and receive a reply", async ({ page, llm, backend, withBackendProject }) => {
+test("can send a prompt and receive a reply", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)

  const pageErrors: string[] = []
@@ -12,44 +11,42 @@ test("can send a prompt and receive a reply", async ({ page, llm, backend, withB
  }
  page.on("pageerror", onPageError)

+  await gotoSession()
+
+  const token = `E2E_OK_${Date.now()}`
+
+  const prompt = page.locator(promptSelector)
+  await prompt.click()
+  await page.keyboard.type(`Reply with exactly: ${token}`)
+  await page.keyboard.press("Enter")
+
+  await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
+
+  const sessionID = (() => {
+    const id = sessionIDFromUrl(page.url())
+    if (!id) throw new Error(`Failed to parse session id from url: ${page.url()}`)
+    return id
+  })()
+
  try {
-    await withMockOpenAI({
-      serverUrl: backend.url,
-      llmUrl: llm.url,
-      fn: async () => {
-        const token = `E2E_OK_${Date.now()}`
+    await expect
+      .poll(
+        async () => {
+          const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
+          return messages
+            .filter((m) => m.info.role === "assistant")
+            .flatMap((m) => m.parts)
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n")
+        },
+        { timeout: 90_000 },
+      )

-        await llm.textMatch(titleMatch, "E2E Title")
-        await llm.textMatch(promptMatch(token), token)
-
-        await withBackendProject(
-          async (project) => {
-            const prompt = page.locator(promptSelector)
-            await prompt.click()
-            await page.keyboard.type(`Reply with exactly: ${token}`)
-            await page.keyboard.press("Enter")
-
-            await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-
-            const sessionID = (() => {
-              const id = sessionIDFromUrl(page.url())
-              if (!id) throw new Error(`Failed to parse session id from url: ${page.url()}`)
-              return id
-            })()
-            project.trackSession(sessionID)
-
-            await expect.poll(() => llm.calls()).toBeGreaterThanOrEqual(1)
-
-            await expect.poll(() => assistantText(project.sdk, sessionID), { timeout: 30_000 }).toContain(token)
-          },
-          {
-            model: openaiModel,
-          },
-        )
-      },
-    })
+      .toContain(token)
  } finally {
    page.off("pageerror", onPageError)
+    await cleanupSession({ sdk, sessionID })
  }

  if (pageErrors.length > 0) {
@@ -1,7 +1,7 @@
 import { seedSessionTask, withSession } from "../actions"
 import { test, expect } from "../fixtures"

-test("task tool child-session link does not trigger stale show errors", async ({ page, withBackendProject }) => {
+test("task tool child-session link does not trigger stale show errors", async ({ page, sdk, gotoSession }) => {
  test.setTimeout(120_000)

  const errs: string[] = []
@@ -10,32 +10,28 @@ test("task tool child-session link does not trigger stale show errors", async ({
  }
  page.on("pageerror", onError)

-  await withBackendProject(async ({ gotoSession, trackSession, sdk }) => {
-    await withSession(sdk, `e2e child nav ${Date.now()}`, async (session) => {
-      trackSession(session.id)
-      const child = await seedSessionTask(sdk, {
-        sessionID: session.id,
-        description: "Open child session",
-        prompt: "Search the repository for AssistantParts and then reply with exactly CHILD_OK.",
-      })
-      trackSession(child.sessionID)
-
-      try {
-        await gotoSession(session.id)
-
-        const link = page
-          .locator("a.subagent-link")
-          .filter({ hasText: /open child session/i })
-          .first()
-        await expect(link).toBeVisible({ timeout: 30_000 })
-        await link.click()
-
-        await expect(page).toHaveURL(new RegExp(`/session/${child.sessionID}(?:[/?#]|$)`), { timeout: 30_000 })
-        await page.waitForTimeout(1000)
-        expect(errs).toEqual([])
-      } finally {
-        page.off("pageerror", onError)
-      }
+  await withSession(sdk, `e2e child nav ${Date.now()}`, async (session) => {
+    const child = await seedSessionTask(sdk, {
+      sessionID: session.id,
+      description: "Open child session",
+      prompt: "Search the repository for AssistantParts and then reply with exactly CHILD_OK.",
    })
+
+    try {
+      await gotoSession(session.id)
+
+      const link = page
+        .locator("a.subagent-link")
+        .filter({ hasText: /open child session/i })
+        .first()
+      await expect(link).toBeVisible({ timeout: 30_000 })
+      await link.click()
+
+      await expect(page).toHaveURL(new RegExp(`/session/${child.sessionID}(?:[/?#]|$)`), { timeout: 30_000 })
+      await page.waitForTimeout(1000)
+      expect(errs).toEqual([])
+    } finally {
+      page.off("pageerror", onError)
+    }
  })
 })
@@ -13,7 +13,6 @@ import {
  sessionComposerDockSelector,
  sessionTodoToggleButtonSelector,
 } from "../selectors"
-import { modKey } from "../utils"

 type Sdk = Parameters<typeof clearSessionDockSeed>[0]
 type PermissionRule = { permission: string; pattern: string; action: "allow" | "deny" | "ask" }
@@ -256,50 +255,168 @@ async function withMockPermission<T>(
  }
 }

-test("default dock shows prompt input", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock default", async (session) => {
-      await project.gotoSession(session.id)
+test("default dock shows prompt input", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock default", async (session) => {
+    await gotoSession(session.id)

-      await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
-      await expect(page.locator(promptSelector)).toBeVisible()
-      await expect(page.locator(questionDockSelector)).toHaveCount(0)
-      await expect(page.locator(permissionDockSelector)).toHaveCount(0)
+    await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
+    await expect(page.locator(promptSelector)).toBeVisible()
+    await expect(page.locator(questionDockSelector)).toHaveCount(0)
+    await expect(page.locator(permissionDockSelector)).toHaveCount(0)

-      await page.locator(promptSelector).click()
-      await expect(page.locator(promptSelector)).toBeFocused()
+    await page.locator(promptSelector).click()
+    await expect(page.locator(promptSelector)).toBeFocused()
+  })
+})
+
+test("auto-accept toggle works before first submit", async ({ page, gotoSession }) => {
+  await gotoSession()
+
+  const button = page.locator('[data-action="prompt-permissions"]').first()
+  await expect(button).toBeVisible()
+  await expect(button).toHaveAttribute("aria-pressed", "false")
+
+  await setAutoAccept(page, true)
+  await setAutoAccept(page, false)
+})
+
+test("blocked question flow unblocks after submit", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock question", async (session) => {
+    await withDockSeed(sdk, session.id, async () => {
+      await gotoSession(session.id)
+
+      await seedSessionQuestion(sdk, {
+        sessionID: session.id,
+        questions: [
+          {
+            header: "Need input",
+            question: "Pick one option",
+            options: [
+              { label: "Continue", description: "Continue now" },
+              { label: "Stop", description: "Stop here" },
+            ],
+          },
+        ],
+      })
+
+      const dock = page.locator(questionDockSelector)
+      await expectQuestionBlocked(page)
+
+      await dock.locator('[data-slot="question-option"]').first().click()
+      await dock.getByRole("button", { name: /submit/i }).click()
+
+      await expectQuestionOpen(page)
    })
  })
 })

-test("auto-accept toggle works before first submit", async ({ page, withBackendProject }) => {
-  await withBackendProject(async ({ gotoSession }) => {
-    await gotoSession()
-
-    const button = page.locator('[data-action="prompt-permissions"]').first()
-    await expect(button).toBeVisible()
-    await expect(button).toHaveAttribute("aria-pressed", "false")
-
-    await setAutoAccept(page, true)
+test("blocked permission flow supports allow once", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission once", async (session) => {
+    await gotoSession(session.id)
    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_once",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-once"],
+        metadata: { description: "Need permission for command" },
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)
+
+        await clearPermissionDock(page, /allow once/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
  })
 })

-test("blocked question flow unblocks after submit", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock question", async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
+test("blocked permission flow supports reject", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission reject", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_reject",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-reject"],
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)

-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
+        await clearPermissionDock(page, /deny/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
+  })
+})
+
+test("blocked permission flow supports allow always", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission always", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_always",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-always"],
+        metadata: { description: "Need permission for command" },
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)
+
+        await clearPermissionDock(page, /allow always/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
+  })
+})
+
+test("child session question request blocks parent dock and unblocks after submit", async ({
+  page,
+  sdk,
+  gotoSession,
+}) => {
+  await withDockSession(sdk, "e2e composer dock child question parent", async (session) => {
+    await gotoSession(session.id)
+
+    const child = await sdk.session
+      .create({
+        title: "e2e composer dock child question",
+        parentID: session.id,
+      })
+      .then((r) => r.data)
+    if (!child?.id) throw new Error("Child session create did not return an id")
+
+    try {
+      await withDockSeed(sdk, child.id, async () => {
+        await seedSessionQuestion(sdk, {
+          sessionID: child.id,
          questions: [
            {
-              header: "Need input",
-              question: "Pick one option",
+              header: "Child input",
+              question: "Pick one child option",
              options: [
-                { label: "Continue", description: "Continue now" },
-                { label: "Stop", description: "Stop here" },
+                { label: "Continue", description: "Continue child" },
+                { label: "Stop", description: "Stop child" },
              ],
            },
          ],
@@ -313,96 +430,40 @@ test("blocked question flow unblocks after submit", async ({ page, withBackendPr

        await expectQuestionOpen(page)
      })
-    })
+    } finally {
+      await cleanupSession({ sdk, sessionID: child.id })
+    }
  })
 })

-test("blocked question flow supports keyboard shortcuts", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock question keyboard", async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
+test("child session permission request blocks parent dock and supports allow once", async ({
+  page,
+  sdk,
+  gotoSession,
+}) => {
+  await withDockSession(sdk, "e2e composer dock child permission parent", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)

-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
-          questions: [
-            {
-              header: "Need input",
-              question: "Pick one option",
-              options: [
-                { label: "Continue", description: "Continue now" },
-                { label: "Stop", description: "Stop here" },
-              ],
-            },
-          ],
-        })
-
-        const dock = page.locator(questionDockSelector)
-        const first = dock.locator('[data-slot="question-option"]').first()
-        const second = dock.locator('[data-slot="question-option"]').nth(1)
-
-        await expectQuestionBlocked(page)
-        await expect(first).toBeFocused()
-
-        await page.keyboard.press("ArrowDown")
-        await expect(second).toBeFocused()
-
-        await page.keyboard.press("Space")
-        await page.keyboard.press(`${modKey}+Enter`)
-        await expectQuestionOpen(page)
+    const child = await sdk.session
+      .create({
+        title: "e2e composer dock child permission",
+        parentID: session.id,
      })
-    })
-  })
-})
+      .then((r) => r.data)
+    if (!child?.id) throw new Error("Child session create did not return an id")

-test("blocked question flow supports escape dismiss", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock question escape", async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
-
-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
-          questions: [
-            {
-              header: "Need input",
-              question: "Pick one option",
-              options: [
-                { label: "Continue", description: "Continue now" },
-                { label: "Stop", description: "Stop here" },
-              ],
-            },
-          ],
-        })
-
-        const dock = page.locator(questionDockSelector)
-        const first = dock.locator('[data-slot="question-option"]').first()
-
-        await expectQuestionBlocked(page)
-        await expect(first).toBeFocused()
-
-        await page.keyboard.press("Escape")
-        await expectQuestionOpen(page)
-      })
-    })
-  })
-})
-
-test("blocked permission flow supports allow once", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock permission once", async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
+    try {
      await withMockPermission(
        page,
        {
-          id: "per_e2e_once",
-          sessionID: session.id,
+          id: "per_e2e_child",
+          sessionID: child.id,
          permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-once"],
-          metadata: { description: "Need permission for command" },
+          patterns: ["/tmp/opencode-e2e-perm-child"],
+          metadata: { description: "Need child permission" },
        },
-        undefined,
+        { child },
        async (state) => {
          await page.goto(page.url())
          await expectPermissionBlocked(page)
@@ -410,218 +471,67 @@ test("blocked permission flow supports allow once", async ({ page, withBackendPr
          await clearPermissionDock(page, /allow once/i)
          await state.resolved()
          await page.goto(page.url())
+
          await expectPermissionOpen(page)
        },
      )
-    })
+    } finally {
+      await cleanupSession({ sdk, sessionID: child.id })
+    }
  })
 })

-test("blocked permission flow supports reject", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock permission reject", async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-      await withMockPermission(
-        page,
-        {
-          id: "per_e2e_reject",
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-reject"],
-        },
-        undefined,
-        async (state) => {
-          await page.goto(page.url())
-          await expectPermissionBlocked(page)
+test("todo dock transitions and collapse behavior", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock todo", async (session) => {
+    const dock = await todoDock(page, session.id)
+    await gotoSession(session.id)
+    await expect(page.locator(sessionComposerDockSelector)).toBeVisible()

-          await clearPermissionDock(page, /deny/i)
-          await state.resolved()
-          await page.goto(page.url())
-          await expectPermissionOpen(page)
-        },
-      )
-    })
+    try {
+      await dock.open([
+        { content: "first task", status: "pending", priority: "high" },
+        { content: "second task", status: "in_progress", priority: "medium" },
+      ])
+      await dock.expectOpen(["pending", "in_progress"])
+
+      await dock.collapse()
+      await dock.expectCollapsed(["pending", "in_progress"])
+
+      await dock.expand()
+      await dock.expectOpen(["pending", "in_progress"])
+
+      await dock.finish([
+        { content: "first task", status: "completed", priority: "high" },
+        { content: "second task", status: "cancelled", priority: "medium" },
+      ])
+      await dock.expectClosed()
+    } finally {
+      await dock.clear()
+    }
  })
 })

-test("blocked permission flow supports allow always", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock permission always", async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-      await withMockPermission(
-        page,
-        {
-          id: "per_e2e_always",
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-always"],
-          metadata: { description: "Need permission for command" },
-        },
-        undefined,
-        async (state) => {
-          await page.goto(page.url())
-          await expectPermissionBlocked(page)
+test("keyboard focus stays off prompt while blocked", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock keyboard", async (session) => {
+    await withDockSeed(sdk, session.id, async () => {
+      await gotoSession(session.id)

-          await clearPermissionDock(page, /allow always/i)
-          await state.resolved()
-          await page.goto(page.url())
-          await expectPermissionOpen(page)
-        },
-      )
-    })
-  })
-})
-
-test("child session question request blocks parent dock and unblocks after submit", async ({
-  page,
-  withBackendProject,
-}) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock child question parent", async (session) => {
-      await project.gotoSession(session.id)
-
-      const child = await project.sdk.session
-        .create({
-          title: "e2e composer dock child question",
-          parentID: session.id,
-        })
-        .then((r) => r.data)
-      if (!child?.id) throw new Error("Child session create did not return an id")
-
-      try {
-        await withDockSeed(project.sdk, child.id, async () => {
-          await seedSessionQuestion(project.sdk, {
-            sessionID: child.id,
-            questions: [
-              {
-                header: "Child input",
-                question: "Pick one child option",
-                options: [
-                  { label: "Continue", description: "Continue child" },
-                  { label: "Stop", description: "Stop child" },
-                ],
-              },
-            ],
-          })
-
-          const dock = page.locator(questionDockSelector)
-          await expectQuestionBlocked(page)
-
-          await dock.locator('[data-slot="question-option"]').first().click()
-          await dock.getByRole("button", { name: /submit/i }).click()
-
-          await expectQuestionOpen(page)
-        })
-      } finally {
-        await cleanupSession({ sdk: project.sdk, sessionID: child.id })
-      }
-    })
-  })
-})
-
-test("child session permission request blocks parent dock and supports allow once", async ({
-  page,
-  withBackendProject,
-}) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock child permission parent", async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-
-      const child = await project.sdk.session
-        .create({
-          title: "e2e composer dock child permission",
-          parentID: session.id,
-        })
-        .then((r) => r.data)
-      if (!child?.id) throw new Error("Child session create did not return an id")
-
-      try {
-        await withMockPermission(
-          page,
+      await seedSessionQuestion(sdk, {
+        sessionID: session.id,
+        questions: [
          {
-            id: "per_e2e_child",
-            sessionID: child.id,
-            permission: "bash",
-            patterns: ["/tmp/opencode-e2e-perm-child"],
-            metadata: { description: "Need child permission" },
+            header: "Need input",
+            question: "Pick one option",
+            options: [{ label: "Continue", description: "Continue now" }],
          },
-          { child },
-          async (state) => {
-            await page.goto(page.url())
-            await expectPermissionBlocked(page)
-
-            await clearPermissionDock(page, /allow once/i)
-            await state.resolved()
-            await page.goto(page.url())
-
-            await expectPermissionOpen(page)
-          },
-        )
-      } finally {
-        await cleanupSession({ sdk: project.sdk, sessionID: child.id })
-      }
-    })
-  })
-})
-
-test("todo dock transitions and collapse behavior", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock todo", async (session) => {
-      const dock = await todoDock(page, session.id)
-      await project.gotoSession(session.id)
-      await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
-
-      try {
-        await dock.open([
-          { content: "first task", status: "pending", priority: "high" },
-          { content: "second task", status: "in_progress", priority: "medium" },
-        ])
-        await dock.expectOpen(["pending", "in_progress"])
-
-        await dock.collapse()
-        await dock.expectCollapsed(["pending", "in_progress"])
-
-        await dock.expand()
-        await dock.expectOpen(["pending", "in_progress"])
-
-        await dock.finish([
-          { content: "first task", status: "completed", priority: "high" },
-          { content: "second task", status: "cancelled", priority: "medium" },
-        ])
-        await dock.expectClosed()
-      } finally {
-        await dock.clear()
-      }
-    })
-  })
-})
-
-test("keyboard focus stays off prompt while blocked", async ({ page, withBackendProject }) => {
-  await withBackendProject(async (project) => {
-    await withDockSession(project.sdk, "e2e composer dock keyboard", async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
-
-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
-          questions: [
-            {
-              header: "Need input",
-              question: "Pick one option",
-              options: [{ label: "Continue", description: "Continue now" }],
-            },
-          ],
-        })
-
-        await expectQuestionBlocked(page)
-
-        await page.locator("main").click({ position: { x: 5, y: 5 } })
-        await page.keyboard.type("abc")
-        await expect(page.locator(promptSelector)).toHaveCount(0)
+        ],
      })
+
+      await expectQuestionBlocked(page)
+
+      await page.locator("main").click({ position: { x: 5, y: 5 } })
+      await page.keyboard.type("abc")
+      await expect(page.locator(promptSelector)).toHaveCount(0)
    })
  })
 })
@@ -49,13 +49,13 @@ async function seedConversation(input: {
  return { prompt, userMessageID }
 }

-test("slash undo sets revert and restores prior prompt", async ({ page, withBackendProject }) => {
+test("slash undo sets revert and restores prior prompt", async ({ page, withProject }) => {
  test.setTimeout(120_000)

  const token = `undo_${Date.now()}`

-  await withBackendProject(async (project) => {
-    const sdk = project.sdk
+  await withProject(async (project) => {
+    const sdk = createSdk(project.directory)

    await withSession(sdk, `e2e undo ${Date.now()}`, async (session) => {
      await project.gotoSession(session.id)
@@ -81,13 +81,13 @@ test("slash undo sets revert and restores prior prompt", async ({ page, withBack
  })
 })

-test("slash redo clears revert and restores latest state", async ({ page, withBackendProject }) => {
+test("slash redo clears revert and restores latest state", async ({ page, withProject }) => {
  test.setTimeout(120_000)

  const token = `redo_${Date.now()}`

-  await withBackendProject(async (project) => {
-    const sdk = project.sdk
+  await withProject(async (project) => {
+    const sdk = createSdk(project.directory)

    await withSession(sdk, `e2e redo ${Date.now()}`, async (session) => {
      await project.gotoSession(session.id)
@@ -128,14 +128,14 @@ test("slash redo clears revert and restores latest state", async ({ page, withBa
  })
 })

-test("slash undo/redo traverses multi-step revert stack", async ({ page, withBackendProject }) => {
+test("slash undo/redo traverses multi-step revert stack", async ({ page, withProject }) => {
  test.setTimeout(120_000)

  const firstToken = `undo_redo_first_${Date.now()}`
  const secondToken = `undo_redo_second_${Date.now()}`

-  await withBackendProject(async (project) => {
-    const sdk = project.sdk
+  await withProject(async (project) => {
+    const sdk = createSdk(project.directory)

    await withSession(sdk, `e2e undo redo stack ${Date.now()}`, async (session) => {
      await project.gotoSession(session.id)
@@ -31,152 +31,144 @@ async function seedMessage(sdk: Sdk, sessionID: string) {
    .toBeGreaterThan(0)
 }

-test("session can be renamed via header menu", async ({ page, withBackendProject }) => {
+test("session can be renamed via header menu", async ({ page, sdk, gotoSession }) => {
  const stamp = Date.now()
  const originalTitle = `e2e rename test ${stamp}`
  const renamedTitle = `e2e renamed ${stamp}`

-  await withBackendProject(async (project) => {
-    await withSession(project.sdk, originalTitle, async (session) => {
-      await seedMessage(project.sdk, session.id)
-      await project.gotoSession(session.id)
-      await expect(page.getByRole("heading", { level: 1 }).first()).toHaveText(originalTitle)
+  await withSession(sdk, originalTitle, async (session) => {
+    await seedMessage(sdk, session.id)
+    await gotoSession(session.id)
+    await expect(page.getByRole("heading", { level: 1 }).first()).toHaveText(originalTitle)

-      const menu = await openSessionMoreMenu(page, session.id)
-      await clickMenuItem(menu, /rename/i)
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /rename/i)

-      const input = page.locator(".scroll-view__viewport").locator(inlineInputSelector).first()
-      await expect(input).toBeVisible()
-      await expect(input).toBeFocused()
-      await input.fill(renamedTitle)
-      await expect(input).toHaveValue(renamedTitle)
-      await input.press("Enter")
+    const input = page.locator(".scroll-view__viewport").locator(inlineInputSelector).first()
+    await expect(input).toBeVisible()
+    await expect(input).toBeFocused()
+    await input.fill(renamedTitle)
+    await expect(input).toHaveValue(renamedTitle)
+    await input.press("Enter")

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.title
-          },
-          { timeout: 30_000 },
-        )
-        .toBe(renamedTitle)
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.title
+        },
+        { timeout: 30_000 },
+      )
+      .toBe(renamedTitle)

-      await expect(page.getByRole("heading", { level: 1 }).first()).toHaveText(renamedTitle)
-    })
+    await expect(page.getByRole("heading", { level: 1 }).first()).toHaveText(renamedTitle)
  })
 })

-test("session can be archived via header menu", async ({ page, withBackendProject }) => {
+test("session can be archived via header menu", async ({ page, sdk, gotoSession }) => {
  const stamp = Date.now()
  const title = `e2e archive test ${stamp}`

-  await withBackendProject(async (project) => {
-    await withSession(project.sdk, title, async (session) => {
-      await seedMessage(project.sdk, session.id)
-      await project.gotoSession(session.id)
-      const menu = await openSessionMoreMenu(page, session.id)
-      await clickMenuItem(menu, /archive/i)
+  await withSession(sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
+    await gotoSession(session.id)
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /archive/i)

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.time?.archived
-          },
-          { timeout: 30_000 },
-        )
-        .not.toBeUndefined()
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.time?.archived
+        },
+        { timeout: 30_000 },
+      )
+      .not.toBeUndefined()

-      await openSidebar(page)
-      await expect(page.locator(sessionItemSelector(session.id))).toHaveCount(0)
-    })
+    await openSidebar(page)
+    await expect(page.locator(sessionItemSelector(session.id))).toHaveCount(0)
  })
 })

-test("session can be deleted via header menu", async ({ page, withBackendProject }) => {
+test("session can be deleted via header menu", async ({ page, sdk, gotoSession }) => {
  const stamp = Date.now()
  const title = `e2e delete test ${stamp}`

-  await withBackendProject(async (project) => {
-    await withSession(project.sdk, title, async (session) => {
-      await seedMessage(project.sdk, session.id)
-      await project.gotoSession(session.id)
-      const menu = await openSessionMoreMenu(page, session.id)
-      await clickMenuItem(menu, /delete/i)
-      await confirmDialog(page, /delete/i)
+  await withSession(sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
+    await gotoSession(session.id)
+    const menu = await openSessionMoreMenu(page, session.id)
+    await clickMenuItem(menu, /delete/i)
+    await confirmDialog(page, /delete/i)

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session
-              .get({ sessionID: session.id })
-              .then((r) => r.data)
-              .catch(() => undefined)
-            return data?.id
-          },
-          { timeout: 30_000 },
-        )
-        .toBeUndefined()
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session
+            .get({ sessionID: session.id })
+            .then((r) => r.data)
+            .catch(() => undefined)
+          return data?.id
+        },
+        { timeout: 30_000 },
+      )
+      .toBeUndefined()

-      await openSidebar(page)
-      await expect(page.locator(sessionItemSelector(session.id))).toHaveCount(0)
-    })
+    await openSidebar(page)
+    await expect(page.locator(sessionItemSelector(session.id))).toHaveCount(0)
  })
 })

-test("session can be shared and unshared via header button", async ({ page, withBackendProject }) => {
+test("session can be shared and unshared via header button", async ({ page, sdk, gotoSession }) => {
  test.skip(shareDisabled, "Share is disabled in this environment (OPENCODE_DISABLE_SHARE).")

  const stamp = Date.now()
  const title = `e2e share test ${stamp}`

-  await withBackendProject(async (project) => {
-    await withSession(project.sdk, title, async (session) => {
-      await seedMessage(project.sdk, session.id)
-      await project.gotoSession(session.id)
+  await withSession(sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
+    await gotoSession(session.id)

-      const shared = await openSharePopover(page)
-      const publish = shared.popoverBody.getByRole("button", { name: "Publish" }).first()
-      await expect(publish).toBeVisible({ timeout: 30_000 })
-      await publish.click()
+    const shared = await openSharePopover(page)
+    const publish = shared.popoverBody.getByRole("button", { name: "Publish" }).first()
+    await expect(publish).toBeVisible({ timeout: 30_000 })
+    await publish.click()

-      await expect(shared.popoverBody.getByRole("button", { name: "Unpublish" }).first()).toBeVisible({
-        timeout: 30_000,
-      })
+    await expect(shared.popoverBody.getByRole("button", { name: "Unpublish" }).first()).toBeVisible({
+      timeout: 30_000,
+    })

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.share?.url || undefined
-          },
-          { timeout: 30_000 },
-        )
-        .not.toBeUndefined()
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .not.toBeUndefined()

-      const unpublish = shared.popoverBody.getByRole("button", { name: "Unpublish" }).first()
-      await expect(unpublish).toBeVisible({ timeout: 30_000 })
-      await unpublish.click()
+    const unpublish = shared.popoverBody.getByRole("button", { name: "Unpublish" }).first()
+    await expect(unpublish).toBeVisible({ timeout: 30_000 })
+    await unpublish.click()

-      await expect(shared.popoverBody.getByRole("button", { name: "Publish" }).first()).toBeVisible({
-        timeout: 30_000,
-      })
+    await expect(shared.popoverBody.getByRole("button", { name: "Publish" }).first()).toBeVisible({
+      timeout: 30_000,
+    })

-      await expect
-        .poll(
-          async () => {
-            const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-            return data?.share?.url || undefined
-          },
-          { timeout: 30_000 },
-        )
-        .toBeUndefined()
+    await expect
+      .poll(
+        async () => {
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          return data?.share?.url || undefined
+        },
+        { timeout: 30_000 },
+      )
+      .toBeUndefined()

-      const unshared = await openSharePopover(page)
-      await expect(unshared.popoverBody.getByRole("button", { name: "Publish" }).first()).toBeVisible({
-        timeout: 30_000,
-      })
+    const unshared = await openSharePopover(page)
+    await expect(unshared.popoverBody.getByRole("button", { name: "Publish" }).first()).toBeVisible({
+      timeout: 30_000,
    })
  })
 })
@@ -26,21 +26,21 @@ export const serverNamePattern = new RegExp(`(?:${serverNames.map(escape).join("
 export const modKey = process.platform === "darwin" ? "Meta" : "Control"
 export const terminalToggleKey = "Control+Backquote"

-export function createSdk(directory?: string, baseUrl = serverUrl) {
-  return createOpencodeClient({ baseUrl, directory, throwOnError: true })
+export function createSdk(directory?: string) {
+  return createOpencodeClient({ baseUrl: serverUrl, directory, throwOnError: true })
 }

-export async function resolveDirectory(directory: string, baseUrl = serverUrl) {
-  return createSdk(directory, baseUrl)
+export async function resolveDirectory(directory: string) {
+  return createSdk(directory)
    .path.get()
    .then((x) => x.data?.directory ?? directory)
 }

-export async function getWorktree(baseUrl = serverUrl) {
-  const sdk = createSdk(undefined, baseUrl)
+export async function getWorktree() {
+  const sdk = createSdk()
  const result = await sdk.path.get()
  const data = result.data
-  if (!data?.worktree) throw new Error(`Failed to resolve a worktree from ${baseUrl}/path`)
+  if (!data?.worktree) throw new Error(`Failed to resolve a worktree from ${serverUrl}/path`)
  return data.worktree
 }

@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/app",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "description": "",
  "type": "module",
  "exports": {
@@ -1344,9 +1344,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
              autocapitalize={store.mode === "normal" ? "sentences" : "off"}
              autocorrect={store.mode === "normal" ? "on" : "off"}
              spellcheck={store.mode === "normal"}
-              inputMode="text"
-              // @ts-expect-error
-              autocomplete="off"
              onInput={handleInput}
              onPaste={handlePaste}
              onCompositionStart={handleCompositionStart}
@@ -100,30 +100,6 @@ describe("buildRequestParts", () => {
    expect(synthetic).toHaveLength(1)
  })

-  test("adds file parts for @mentions inside comment text", () => {
-    const result = buildRequestParts({
-      prompt: [{ type: "text", content: "look", start: 0, end: 4 }],
-      context: [
-        {
-          key: "ctx:comment-mention",
-          type: "file",
-          path: "src/review.ts",
-          comment: "Compare with @src/shared.ts and @src/review.ts.",
-        },
-      ],
-      images: [],
-      text: "look",
-      messageID: "msg_comment_mentions",
-      sessionID: "ses_comment_mentions",
-      sessionDirectory: "/repo",
-    })
-
-    const files = result.requestParts.filter((part) => part.type === "file")
-    expect(files).toHaveLength(2)
-    expect(files.some((part) => part.type === "file" && part.url === "file:///repo/src/review.ts")).toBe(true)
-    expect(files.some((part) => part.type === "file" && part.url === "file:///repo/src/shared.ts")).toBe(true)
-  })
-
  test("handles Windows paths correctly (simulated on macOS)", () => {
    const prompt: Prompt = [{ type: "file", path: "src\\foo.ts", content: "@src\\foo.ts", start: 0, end: 11 }]

@@ -39,16 +39,6 @@ const absolute = (directory: string, path: string) => {
 const fileQuery = (selection: FileSelection | undefined) =>
  selection ? `?start=${selection.startLine}&end=${selection.endLine}` : ""

-const mention = /(^|[\s([{"'])@(\S+)/g
-
-const parseCommentMentions = (comment: string) => {
-  return Array.from(comment.matchAll(mention)).flatMap((match) => {
-    const path = (match[2] ?? "").replace(/[.,!?;:)}\]"']+$/, "")
-    if (!path) return []
-    return [path]
-  })
-}
-
 const isFileAttachment = (part: Prompt[number]): part is FileAttachmentPart => part.type === "file"
 const isAgentAttachment = (part: Prompt[number]): part is AgentPart => part.type === "agent"

@@ -148,21 +138,6 @@ export function buildRequestParts(input: BuildRequestPartsInput) {

    if (!comment) return [filePart]

-    const mentions = parseCommentMentions(comment).flatMap((path) => {
-      const url = `file://${encodeFilePath(absolute(input.sessionDirectory, path))}`
-      if (used.has(url)) return []
-      used.add(url)
-      return [
-        {
-          id: Identifier.ascending("part"),
-          type: "file",
-          mime: "text/plain",
-          url,
-          filename: getFilename(path),
-        } satisfies PromptRequestPart,
-      ]
-    })
-
    return [
      {
        id: Identifier.ascending("part"),
@@ -178,7 +153,6 @@ export function buildRequestParts(input: BuildRequestPartsInput) {
        }),
      } satisfies PromptRequestPart,
      filePart,
-      ...mentions,
    ]
  })

@@ -1046,9 +1046,6 @@ export default function Page() {
        onLineCommentUpdate={updateCommentInContext}
        onLineCommentDelete={removeCommentFromContext}
        lineCommentActions={reviewCommentActions()}
-        commentMentions={{
-          items: file.searchFilesAndDirectories,
-        }}
        comments={comments.all()}
        focusedComment={comments.focus()}
        onFocusedCommentChange={comments.setFocus}
@@ -29,20 +29,16 @@ function Option(props: {
  label: string
  description?: string
  disabled: boolean
-  ref?: (el: HTMLButtonElement) => void
-  onFocus?: VoidFunction
  onClick: VoidFunction
 }) {
  return (
    <button
      type="button"
-      ref={props.ref}
      data-slot="question-option"
      data-picked={props.picked}
      role={props.multi ? "checkbox" : "radio"}
      aria-checked={props.picked}
      disabled={props.disabled}
-      onFocus={props.onFocus}
      onClick={props.onClick}
    >
      <Mark multi={props.multi} picked={props.picked} />
@@ -70,21 +66,16 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
    custom: cached?.custom ?? ([] as string[]),
    customOn: cached?.customOn ?? ([] as boolean[]),
    editing: false,
-    focus: 0,
  })

  let root: HTMLDivElement | undefined
-  let customRef: HTMLButtonElement | undefined
-  let optsRef: HTMLButtonElement[] = []
  let replied = false
-  let focusFrame: number | undefined

  const question = createMemo(() => questions()[store.tab])
  const options = createMemo(() => question()?.options ?? [])
  const input = createMemo(() => store.custom[store.tab] ?? "")
  const on = createMemo(() => store.customOn[store.tab] === true)
  const multi = createMemo(() => question()?.multiple === true)
-  const count = createMemo(() => options().length + 1)

  const summary = createMemo(() => {
    const n = Math.min(store.tab + 1, total())
@@ -138,29 +129,6 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
    root.style.setProperty("--question-prompt-max-height", `${max}px`)
  }

-  const clamp = (i: number) => Math.max(0, Math.min(count() - 1, i))
-
-  const pickFocus = (tab: number = store.tab) => {
-    const list = questions()[tab]?.options ?? []
-    if (store.customOn[tab] === true) return list.length
-    return Math.max(
-      0,
-      list.findIndex((item) => store.answers[tab]?.includes(item.label) ?? false),
-    )
-  }
-
-  const focus = (i: number) => {
-    const next = clamp(i)
-    setStore("focus", next)
-    if (store.editing) return
-    if (focusFrame !== undefined) cancelAnimationFrame(focusFrame)
-    focusFrame = requestAnimationFrame(() => {
-      focusFrame = undefined
-      const el = next === options().length ? customRef : optsRef[next]
-      el?.focus()
-    })
-  }
-
  onMount(() => {
    let raf: number | undefined
    const update = () => {
@@ -185,12 +153,9 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
      observer.disconnect()
      if (raf !== undefined) cancelAnimationFrame(raf)
    })
-
-    focus(pickFocus())
  })

  onCleanup(() => {
-    if (focusFrame !== undefined) cancelAnimationFrame(focusFrame)
    if (replied) return
    cache.set(props.request.id, {
      tab: store.tab,
@@ -266,7 +231,6 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit

  const customToggle = () => {
    if (sending()) return
-    setStore("focus", options().length)

    if (!multi()) {
      setStore("customOn", store.tab, true)
@@ -286,68 +250,15 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
    const value = input().trim()
    if (value) setStore("answers", store.tab, (current = []) => current.filter((item) => item.trim() !== value))
    setStore("editing", false)
-    focus(options().length)
  }

  const customOpen = () => {
    if (sending()) return
-    setStore("focus", options().length)
    if (!on()) setStore("customOn", store.tab, true)
    setStore("editing", true)
    customUpdate(input(), true)
  }

-  const move = (step: number) => {
-    if (store.editing || sending()) return
-    focus(store.focus + step)
-  }
-
-  const nav = (event: KeyboardEvent) => {
-    if (event.defaultPrevented) return
-
-    if (event.key === "Escape") {
-      event.preventDefault()
-      void reject()
-      return
-    }
-
-    const mod = (event.metaKey || event.ctrlKey) && !event.altKey
-    if (mod && event.key === "Enter") {
-      if (event.repeat) return
-      event.preventDefault()
-      next()
-      return
-    }
-
-    const target =
-      event.target instanceof HTMLElement ? event.target.closest('[data-slot="question-options"]') : undefined
-    if (store.editing) return
-    if (!(target instanceof HTMLElement)) return
-    if (event.altKey || event.ctrlKey || event.metaKey) return
-
-    if (event.key === "ArrowDown" || event.key === "ArrowRight") {
-      event.preventDefault()
-      move(1)
-      return
-    }
-
-    if (event.key === "ArrowUp" || event.key === "ArrowLeft") {
-      event.preventDefault()
-      move(-1)
-      return
-    }
-
-    if (event.key === "Home") {
-      event.preventDefault()
-      focus(0)
-      return
-    }
-
-    if (event.key !== "End") return
-    event.preventDefault()
-    focus(count() - 1)
-  }
-
  const selectOption = (optIndex: number) => {
    if (sending()) return

@@ -359,7 +270,6 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
    const opt = options()[optIndex]
    if (!opt) return
    if (multi()) {
-      setStore("editing", false)
      toggle(opt.label)
      return
    }
@@ -369,7 +279,6 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
  const commitCustom = () => {
    setStore("editing", false)
    customUpdate(input())
-    focus(options().length)
  }

  const resizeInput = (el: HTMLTextAreaElement) => {
@@ -399,33 +308,27 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
      return
    }

-    const tab = store.tab + 1
-    setStore("tab", tab)
+    setStore("tab", store.tab + 1)
    setStore("editing", false)
-    focus(pickFocus(tab))
  }

  const back = () => {
    if (sending()) return
    if (store.tab <= 0) return
-    const tab = store.tab - 1
-    setStore("tab", tab)
+    setStore("tab", store.tab - 1)
    setStore("editing", false)
-    focus(pickFocus(tab))
  }

  const jump = (tab: number) => {
    if (sending()) return
    setStore("tab", tab)
    setStore("editing", false)
-    focus(pickFocus(tab))
  }

  return (
    <DockPrompt
      kind="question"
      ref={(el) => (root = el)}
-      onKeyDown={nav}
      header={
        <>
          <div data-slot="question-header-title">{summary()}</div>
@@ -448,7 +351,7 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
      }
      footer={
        <>
-          <Button variant="ghost" size="large" disabled={sending()} onClick={reject} aria-keyshortcuts="Escape">
+          <Button variant="ghost" size="large" disabled={sending()} onClick={reject}>
            {language.t("ui.common.dismiss")}
          </Button>
          <div data-slot="question-footer-actions">
@@ -457,13 +360,7 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
                {language.t("ui.common.back")}
              </Button>
            </Show>
-            <Button
-              variant={last() ? "primary" : "secondary"}
-              size="large"
-              disabled={sending()}
-              onClick={next}
-              aria-keyshortcuts="Meta+Enter Control+Enter"
-            >
+            <Button variant={last() ? "primary" : "secondary"} size="large" disabled={sending()} onClick={next}>
              {last() ? language.t("ui.common.submit") : language.t("ui.common.next")}
            </Button>
          </div>
@@ -483,8 +380,6 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
              label={opt.label}
              description={opt.description}
              disabled={sending()}
-              ref={(el) => (optsRef[i()] = el)}
-              onFocus={() => setStore("focus", i())}
              onClick={() => selectOption(i())}
            />
          )}
@@ -495,14 +390,12 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
          fallback={
            <button
              type="button"
-              ref={customRef}
              data-slot="question-option"
              data-custom="true"
              data-picked={on()}
              role={multi() ? "checkbox" : "radio"}
              aria-checked={on()}
              disabled={sending()}
-              onFocus={() => setStore("focus", options().length)}
              onClick={customOpen}
            >
              <Mark multi={multi()} picked={on()} onClick={toggleCustomMark} />
@@ -547,10 +440,8 @@ export const SessionQuestionDock: Component<{ request: QuestionRequest; onSubmit
                  if (e.key === "Escape") {
                    e.preventDefault()
                    setStore("editing", false)
-                    focus(options().length)
                    return
                  }
-                  if ((e.metaKey || e.ctrlKey) && !e.altKey) return
                  if (e.key !== "Enter" || e.shiftKey) return
                  e.preventDefault()
                  commitCustom()
@@ -302,9 +302,6 @@ export function FileTabContent(props: { tab: string }) {
    comments: fileComments,
    label: language.t("ui.lineComment.submit"),
    draftKey: () => path() ?? props.tab,
-    mention: {
-      items: file.searchFilesAndDirectories,
-    },
    state: {
      opened: () => note.openedComment,
      setOpened: (id) => setNote("openedComment", id),
@@ -30,9 +30,6 @@ export interface SessionReviewTabProps {
  onFocusedCommentChange?: (focus: { file: string; id: string } | null) => void
  focusedFile?: string
  onScrollRef?: (el: HTMLDivElement) => void
-  commentMentions?: {
-    items: (query: string) => string[] | Promise<string[]>
-  }
  classes?: {
    root?: string
    header?: string
@@ -165,7 +162,6 @@ export function SessionReviewTab(props: SessionReviewTabProps) {
      onLineCommentUpdate={props.onLineCommentUpdate}
      onLineCommentDelete={props.onLineCommentDelete}
      lineCommentActions={props.lineCommentActions}
-      lineCommentMention={props.commentMentions}
      comments={props.comments}
      focusedComment={props.focusedComment}
      onFocusedCommentChange={props.onFocusedCommentChange}
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-app",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/console-core",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-function",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/console-mail",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "dependencies": {
    "@jsx-email/all": "2.2.3",
    "@jsx-email/cli": "1.4.3",
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop-electron",
  "private": true,
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "homepage": "https://opencode.ai",
@@ -9,7 +9,6 @@ import { app } from "electron"
 import treeKill from "tree-kill"

 import { WSL_ENABLED_KEY } from "./constants"
-import { getUserShell, loadShellEnv, mergeShellEnv } from "./shell-env"
 import { store } from "./store"

 const CLI_INSTALL_DIR = ".opencode/bin"
@@ -136,7 +135,7 @@ export function spawnCommand(args: string, extraEnv: Record<string, string>) {
  const base = Object.fromEntries(
    Object.entries(process.env).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
  )
-  const env = {
+  const envs = {
    ...base,
    OPENCODE_EXPERIMENTAL_ICON_DISCOVERY: "true",
    OPENCODE_EXPERIMENTAL_FILEWATCHER: "true",
@@ -144,10 +143,8 @@ export function spawnCommand(args: string, extraEnv: Record<string, string>) {
    XDG_STATE_HOME: app.getPath("userData"),
    ...extraEnv,
  }
-  const shell = process.platform === "win32" ? null : getUserShell()
-  const envs = shell ? mergeShellEnv(loadShellEnv(shell), env) : env

-  const { cmd, cmdArgs } = buildCommand(args, envs, shell)
+  const { cmd, cmdArgs } = buildCommand(args, envs)
  console.log(`[cli] Executing: ${cmd} ${cmdArgs.join(" ")}`)
  const child = spawn(cmd, cmdArgs, {
    env: envs,
@@ -213,7 +210,7 @@ function handleSqliteProgress(events: EventEmitter, line: string) {
  return false
 }

-function buildCommand(args: string, env: Record<string, string>, shell: string | null) {
+function buildCommand(args: string, env: Record<string, string>) {
  if (process.platform === "win32" && isWslEnabled()) {
    console.log(`[cli] Using WSL mode`)
    const version = app.getVersion()
@@ -236,10 +233,10 @@ function buildCommand(args: string, env: Record<string, string>, shell: string |
  }

  const sidecar = getSidecarPath()
-  const user = shell || getUserShell()
-  const line = user.endsWith("/nu") ? `^\"${sidecar}\" ${args}` : `\"${sidecar}\" ${args}`
-  console.log(`[cli] Unix mode, shell: ${user}, command: ${line}`)
-  return { cmd: user, cmdArgs: ["-l", "-c", line] }
+  const shell = process.env.SHELL || "/bin/sh"
+  const line = shell.endsWith("/nu") ? `^\"${sidecar}\" ${args}` : `\"${sidecar}\" ${args}`
+  console.log(`[cli] Unix mode, shell: ${shell}, command: ${line}`)
+  return { cmd: shell, cmdArgs: ["-l", "-c", line] }
 }

 function envPrefix(env: Record<string, string>) {
@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import { isNushell, mergeShellEnv, parseShellEnv } from "./shell-env"
-
-describe("shell env", () => {
-  test("parseShellEnv supports null-delimited pairs", () => {
-    const env = parseShellEnv(Buffer.from("PATH=/usr/bin:/bin\0FOO=bar=baz\0\0"))
-
-    expect(env.PATH).toBe("/usr/bin:/bin")
-    expect(env.FOO).toBe("bar=baz")
-  })
-
-  test("parseShellEnv ignores invalid entries", () => {
-    const env = parseShellEnv(Buffer.from("INVALID\0=empty\0OK=1\0"))
-
-    expect(Object.keys(env).length).toBe(1)
-    expect(env.OK).toBe("1")
-  })
-
-  test("mergeShellEnv keeps explicit overrides", () => {
-    const env = mergeShellEnv(
-      {
-        PATH: "/shell/path",
-        HOME: "/tmp/home",
-      },
-      {
-        PATH: "/desktop/path",
-        OPENCODE_CLIENT: "desktop",
-      },
-    )
-
-    expect(env.PATH).toBe("/desktop/path")
-    expect(env.HOME).toBe("/tmp/home")
-    expect(env.OPENCODE_CLIENT).toBe("desktop")
-  })
-
-  test("isNushell handles path and binary name", () => {
-    expect(isNushell("nu")).toBe(true)
-    expect(isNushell("/opt/homebrew/bin/nu")).toBe(true)
-    expect(isNushell("C:\\Program Files\\nu.exe")).toBe(true)
-    expect(isNushell("/bin/zsh")).toBe(false)
-  })
-})
@@ -1,88 +0,0 @@
-import { spawnSync } from "node:child_process"
-import { basename } from "node:path"
-
-const SHELL_ENV_TIMEOUT = 5_000
-
-type Probe = { type: "Loaded"; value: Record<string, string> } | { type: "Timeout" } | { type: "Unavailable" }
-
-export function getUserShell() {
-  return process.env.SHELL || "/bin/sh"
-}
-
-export function parseShellEnv(out: Buffer) {
-  const env: Record<string, string> = {}
-  for (const line of out.toString("utf8").split("\0")) {
-    if (!line) continue
-    const ix = line.indexOf("=")
-    if (ix <= 0) continue
-    env[line.slice(0, ix)] = line.slice(ix + 1)
-  }
-  return env
-}
-
-function probeShellEnv(shell: string, mode: "-il" | "-l"): Probe {
-  const out = spawnSync(shell, [mode, "-c", "env -0"], {
-    stdio: ["ignore", "pipe", "ignore"],
-    timeout: SHELL_ENV_TIMEOUT,
-    windowsHide: true,
-  })
-
-  const err = out.error as NodeJS.ErrnoException | undefined
-  if (err) {
-    if (err.code === "ETIMEDOUT") return { type: "Timeout" }
-    console.log(`[cli] Shell env probe failed for ${shell} ${mode}: ${err.message}`)
-    return { type: "Unavailable" }
-  }
-
-  if (out.status !== 0) {
-    console.log(`[cli] Shell env probe exited with non-zero status for ${shell} ${mode}`)
-    return { type: "Unavailable" }
-  }
-
-  const env = parseShellEnv(out.stdout)
-  if (Object.keys(env).length === 0) {
-    console.log(`[cli] Shell env probe returned empty env for ${shell} ${mode}`)
-    return { type: "Unavailable" }
-  }
-
-  return { type: "Loaded", value: env }
-}
-
-export function isNushell(shell: string) {
-  const name = basename(shell).toLowerCase()
-  const raw = shell.toLowerCase()
-  return name === "nu" || name === "nu.exe" || raw.endsWith("\\nu.exe")
-}
-
-export function loadShellEnv(shell: string) {
-  if (isNushell(shell)) {
-    console.log(`[cli] Skipping shell env probe for nushell: ${shell}`)
-    return null
-  }
-
-  const interactive = probeShellEnv(shell, "-il")
-  if (interactive.type === "Loaded") {
-    console.log(`[cli] Loaded shell environment with -il (${Object.keys(interactive.value).length} vars)`)
-    return interactive.value
-  }
-  if (interactive.type === "Timeout") {
-    console.warn(`[cli] Interactive shell env probe timed out: ${shell}`)
-    return null
-  }
-
-  const login = probeShellEnv(shell, "-l")
-  if (login.type === "Loaded") {
-    console.log(`[cli] Loaded shell environment with -l (${Object.keys(login.value).length} vars)`)
-    return login.value
-  }
-
-  console.warn(`[cli] Falling back to app environment: ${shell}`)
-  return null
-}
-
-export function mergeShellEnv(shell: Record<string, string> | null, env: Record<string, string>) {
-  return {
-    ...(shell || {}),
-    ...env,
-  }
-}
@@ -1,7 +1,7 @@
 {
  "name": "@opencode-ai/desktop",
  "private": true,
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/enterprise",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -1,7 +1,7 @@
 id = "opencode"
 name = "OpenCode"
 description = "The open source coding agent."
-version = "1.3.13"
+version = "1.3.11"
 schema_version = 1
 authors = ["Anomaly"]
 repository = "https://github.com/anomalyco/opencode"
@@ -11,26 +11,26 @@ name = "OpenCode"
 icon = "./icons/opencode.svg"

 [agent_servers.opencode.targets.darwin-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.13/opencode-darwin-arm64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.11/opencode-darwin-arm64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.darwin-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.13/opencode-darwin-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.11/opencode-darwin-x64.zip"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-aarch64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.13/opencode-linux-arm64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.11/opencode-linux-arm64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.linux-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.13/opencode-linux-x64.tar.gz"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.11/opencode-linux-x64.tar.gz"
 cmd = "./opencode"
 args = ["acp"]

 [agent_servers.opencode.targets.windows-x86_64]
-archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.13/opencode-windows-x64.zip"
+archive = "https://github.com/anomalyco/opencode/releases/download/v1.3.11/opencode-windows-x64.zip"
 cmd = "./opencode.exe"
 args = ["acp"]
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/function",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "$schema": "https://json.schemastore.org/package.json",
  "private": true,
  "type": "module",
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "name": "opencode",
  "type": "module",
  "license": "MIT",
@@ -102,8 +102,8 @@
    "@opencode-ai/sdk": "workspace:*",
    "@opencode-ai/util": "workspace:*",
    "@openrouter/ai-sdk-provider": "2.3.3",
-    "@opentui/core": "0.1.95",
-    "@opentui/solid": "0.1.95",
+    "@opentui/core": "0.1.93",
+    "@opentui/solid": "0.1.93",
    "@parcel/watcher": "2.5.1",
    "@pierre/diffs": "catalog:",
    "@solid-primitives/event-bus": "1.1.2",
@@ -1,4 +1,4 @@
-import { Cache, Clock, Duration, Effect, Layer, Option, Schema, SchemaGetter, ServiceMap } from "effect"
+import { Clock, Duration, Effect, Layer, Option, Schema, SchemaGetter, ServiceMap } from "effect"
 import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"

 import { makeRuntime } from "@/effect/run-service"
@@ -175,8 +175,9 @@ export namespace Account {
          mapAccountServiceError("HTTP request failed"),
        )

-      const refreshToken = Effect.fnUntraced(function* (row: AccountRow) {
+      const resolveToken = Effect.fnUntraced(function* (row: AccountRow) {
        const now = yield* Clock.currentTimeMillis
+        if (row.token_expiry && row.token_expiry > now) return row.access_token

        const response = yield* executeEffectOk(
          HttpClientRequest.post(`${row.url}/auth/device/token`).pipe(
@@ -207,30 +208,6 @@ export namespace Account {
        return parsed.access_token
      })

-      const refreshTokenCache = yield* Cache.make<AccountID, AccessToken, AccountError>({
-        capacity: Number.POSITIVE_INFINITY,
-        timeToLive: Duration.zero,
-        lookup: Effect.fnUntraced(function* (accountID) {
-          const maybeAccount = yield* repo.getRow(accountID)
-          if (Option.isNone(maybeAccount)) {
-            return yield* Effect.fail(new AccountServiceError({ message: "Account not found during token refresh" }))
-          }
-
-          const account = maybeAccount.value
-          const now = yield* Clock.currentTimeMillis
-          if (account.token_expiry && account.token_expiry > now) return account.access_token
-
-          return yield* refreshToken(account)
-        }),
-      })
-
-      const resolveToken = Effect.fnUntraced(function* (row: AccountRow) {
-        const now = yield* Clock.currentTimeMillis
-        if (row.token_expiry && row.token_expiry > now) return row.access_token
-
-        return yield* Cache.get(refreshTokenCache, row.id)
-      })
-
      const resolveAccess = Effect.fnUntraced(function* (accountID: AccountID) {
        const maybeAccount = yield* repo.getRow(accountID)
        if (Option.isNone(maybeAccount)) return Option.none()
@@ -75,7 +75,6 @@ export namespace Agent {
      const config = yield* Config.Service
      const auth = yield* Auth.Service
      const skill = yield* Skill.Service
-      const provider = yield* Provider.Service

      const state = yield* InstanceState.make<State>(
        Effect.fn("Agent.state")(function* (ctx) {
@@ -331,9 +330,9 @@ export namespace Agent {
          model?: { providerID: ProviderID; modelID: ModelID }
        }) {
          const cfg = yield* config.get()
-          const model = input.model ?? (yield* provider.defaultModel())
-          const resolved = yield* provider.getModel(model.providerID, model.modelID)
-          const language = yield* provider.getLanguage(resolved)
+          const model = input.model ?? (yield* Effect.promise(() => Provider.defaultModel()))
+          const resolved = yield* Effect.promise(() => Provider.getModel(model.providerID, model.modelID))
+          const language = yield* Effect.promise(() => Provider.getLanguage(resolved))

          const system = [PROMPT_GENERATE]
          yield* Effect.promise(() =>
@@ -394,7 +393,6 @@ export namespace Agent {
  )

  export const defaultLayer = layer.pipe(
-    Layer.provide(Provider.defaultLayer),
    Layer.provide(Auth.defaultLayer),
    Layer.provide(Config.defaultLayer),
    Layer.provide(Skill.defaultLayer),
@@ -46,7 +46,7 @@ export namespace Bus {
  export const layer = Layer.effect(
    Service,
    Effect.gen(function* () {
-      const state = yield* InstanceState.make<State>(
+      const cache = yield* InstanceState.make<State>(
        Effect.fn("Bus.state")(function* (ctx) {
          const wildcard = yield* PubSub.unbounded<Payload>()
          const typed = new Map<string, PubSub.PubSub<Payload>>()
@@ -82,13 +82,13 @@ export namespace Bus {

      function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
        return Effect.gen(function* () {
-          const s = yield* InstanceState.get(state)
+          const state = yield* InstanceState.get(cache)
          const payload: Payload = { type: def.type, properties }
          log.info("publishing", { type: def.type })

-          const ps = s.typed.get(def.type)
+          const ps = state.typed.get(def.type)
          if (ps) yield* PubSub.publish(ps, payload)
-          yield* PubSub.publish(s.wildcard, payload)
+          yield* PubSub.publish(state.wildcard, payload)

          const dir = yield* InstanceState.directory
          GlobalBus.emit("event", {
@@ -102,8 +102,8 @@ export namespace Bus {
        log.info("subscribing", { type: def.type })
        return Stream.unwrap(
          Effect.gen(function* () {
-            const s = yield* InstanceState.get(state)
-            const ps = yield* getOrCreate(s, def)
+            const state = yield* InstanceState.get(cache)
+            const ps = yield* getOrCreate(state, def)
            return Stream.fromPubSub(ps)
          }),
        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: def.type }))))
@@ -113,8 +113,8 @@ export namespace Bus {
        log.info("subscribing", { type: "*" })
        return Stream.unwrap(
          Effect.gen(function* () {
-            const s = yield* InstanceState.get(state)
-            return Stream.fromPubSub(s.wildcard)
+            const state = yield* InstanceState.get(cache)
+            return Stream.fromPubSub(state.wildcard)
          }),
        ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: "*" }))))
      }
@@ -150,14 +150,14 @@ export namespace Bus {
        def: D,
        callback: (event: Payload<D>) => unknown,
      ) {
-        const s = yield* InstanceState.get(state)
-        const ps = yield* getOrCreate(s, def)
+        const state = yield* InstanceState.get(cache)
+        const ps = yield* getOrCreate(state, def)
        return yield* on(ps, def.type, callback)
      })

      const subscribeAllCallback = Effect.fn("Bus.subscribeAllCallback")(function* (callback: (event: any) => unknown) {
-        const s = yield* InstanceState.get(state)
-        return yield* on(s.wildcard, "*", callback)
+        const state = yield* InstanceState.get(cache)
+        return yield* on(state.wildcard, "*", callback)
      })

      return Service.of({ publish, subscribe, subscribeAll, subscribeCallback, subscribeAllCallback })
@@ -57,7 +57,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
          return agents()
        },
        current() {
-          return agents().find((x) => x.name === agentStore.current) ?? agents()[0]
+          return agents().find((x) => x.name === agentStore.current)!
        },
        set(name: string) {
          if (!agents().some((x) => x.name === name))
@@ -85,7 +85,7 @@ export namespace Command {

        commands[Default.INIT] = {
          name: Default.INIT,
-          description: "guided AGENTS.md setup",
+          description: "create/update AGENTS.md",
          source: "command",
          get template() {
            return PROMPT_INITIALIZE.replace("${path}", ctx.worktree)
@@ -161,16 +161,16 @@ export namespace Command {
        }
      })

-      const state = yield* InstanceState.make<State>((ctx) => init(ctx))
+      const cache = yield* InstanceState.make<State>((ctx) => init(ctx))

      const get = Effect.fn("Command.get")(function* (name: string) {
-        const s = yield* InstanceState.get(state)
-        return s.commands[name]
+        const state = yield* InstanceState.get(cache)
+        return state.commands[name]
      })

      const list = Effect.fn("Command.list")(function* () {
-        const s = yield* InstanceState.get(state)
-        return Object.values(s.commands)
+        const state = yield* InstanceState.get(cache)
+        return Object.values(state.commands)
      })

      return Service.of({ get, list })
@@ -1,66 +1,10 @@
-Create or update `AGENTS.md` for this repository.
+Please analyze this codebase and create an AGENTS.md file containing:
+1. Build/lint/test commands - especially for running a single test
+2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.

-The goal is a compact instruction file that helps future OpenCode sessions avoid mistakes and ramp up quickly. Every line should answer: "Would an agent likely miss this without help?" If not, leave it out.
+The file you create will be given to agentic coding agents (such as yourself) that operate in this repository. Make it about 150 lines long.
+If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md), make sure to include them.
+
+If there's already an AGENTS.md, improve it if it's located in ${path}

-User-provided focus or constraints (honor these):
 $ARGUMENTS
-
-## How to investigate
-
-Read the highest-value sources first:
- `README*`, root manifests, workspace config, lockfiles
- build, test, lint, formatter, typecheck, and codegen config
- CI workflows and pre-commit / task runner config
- existing instruction files (`AGENTS.md`, `CLAUDE.md`, `.cursor/rules/`, `.cursorrules`, `.github/copilot-instructions.md`)
- repo-local OpenCode config such as `opencode.json`
-
-If architecture is still unclear after reading config and docs, inspect a small number of representative code files to find the real entrypoints, package boundaries, and execution flow. Prefer reading the files that explain how the system is wired together over random leaf files.
-
-Prefer executable sources of truth over prose. If docs conflict with config or scripts, trust the executable source and only keep what you can verify.
-
-## What to extract
-
-Look for the highest-signal facts for an agent working in this repo:
- exact developer commands, especially non-obvious ones
- how to run a single test, a single package, or a focused verification step
- required command order when it matters, such as `lint -> typecheck -> test`
- monorepo or multi-package boundaries, ownership of major directories, and the real app/library entrypoints
- framework or toolchain quirks: generated code, migrations, codegen, build artifacts, special env loading, dev servers, infra deploy flow
- repo-specific style or workflow conventions that differ from defaults
- testing quirks: fixtures, integration test prerequisites, snapshot workflows, required services, flaky or expensive suites
- important constraints from existing instruction files worth preserving
-
-Good `AGENTS.md` content is usually hard-earned context that took reading multiple files to infer.
-
-## Questions
-
-Only ask the user questions if the repo cannot answer something important. Use the `question` tool for one short batch at most.
-
-Good questions:
- undocumented team conventions
- branch / PR / release expectations
- missing setup or test prerequisites that are known but not written down
-
-Do not ask about anything the repo already makes clear.
-
-## Writing rules
-
-Include only high-signal, repo-specific guidance such as:
- exact commands and shortcuts the agent would otherwise guess wrong
- architecture notes that are not obvious from filenames
- conventions that differ from language or framework defaults
- setup requirements, environment quirks, and operational gotchas
- references to existing instruction sources that matter
-
-Exclude:
- generic software advice
- long tutorials or exhaustive file trees
- obvious language conventions
- speculative claims or anything you could not verify
- content better stored in another file referenced via `opencode.json` `instructions`
-
-When in doubt, omit.
-
-Prefer short sections and bullets. If the repo is simple, keep the file simple. If the repo is large, summarize the few structural facts that actually change how an agent should work.
-
-If `AGENTS.md` already exists at `${path}`, improve it in place rather than rewriting blindly. Preserve verified useful guidance, delete fluff or stale claims, and reconcile it with the current codebase.
@@ -386,17 +386,9 @@ export const make = Effect.gen(function* () {
                if (code !== 0 && Predicate.isNotNull(code)) return yield* Effect.ignore(kill(killGroup))
                return yield* Effect.void
              }
-              const send = (s: NodeJS.Signals) =>
-                Effect.catch(killGroup(command, proc, s), () => killOne(command, proc, s))
-              const sig = command.options.killSignal ?? "SIGTERM"
-              const attempt = send(sig).pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid)
-              const escalated = command.options.forceKillAfter
-                ? Effect.timeoutOrElse(attempt, {
-                    duration: command.options.forceKillAfter,
-                    orElse: () => send("SIGKILL").pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid),
-                  })
-                : attempt
-              return yield* Effect.ignore(escalated)
+              return yield* kill((command, proc, signal) =>
+                Effect.catch(killGroup(command, proc, signal), () => killOne(command, proc, signal)),
+              ).pipe(Effect.andThen(Deferred.await(signal)), Effect.ignore)
            }),
          )

@@ -421,17 +413,14 @@ export const make = Effect.gen(function* () {
                ),
              )
            }),
-            kill: (opts?: ChildProcess.KillOptions) => {
-              const sig = opts?.killSignal ?? "SIGTERM"
-              const send = (s: NodeJS.Signals) =>
-                Effect.catch(killGroup(command, proc, s), () => killOne(command, proc, s))
-              const attempt = send(sig).pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid)
-              if (!opts?.forceKillAfter) return attempt
-              return Effect.timeoutOrElse(attempt, {
-                duration: opts.forceKillAfter,
-                orElse: () => send("SIGKILL").pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid),
-              })
-            },
+            kill: (opts?: ChildProcess.KillOptions) =>
+              timeout(
+                proc,
+                command,
+                opts,
+              )((command, proc, signal) =>
+                Effect.catch(killGroup(command, proc, signal), () => killOne(command, proc, signal)),
+              ).pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid),
          })
        }
        case "PipedCommand": {
@@ -24,9 +24,9 @@ export namespace InstanceState {
    return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
  }

-  export const context = Effect.gen(function* () {
+  export const context = Effect.fnUntraced(function* () {
    return (yield* InstanceRef) ?? Instance.current
-  })
+  })()

  export const directory = Effect.map(context, (ctx) => ctx.directory)

@@ -37,9 +37,9 @@ export namespace InstanceState {
      const cache = yield* ScopedCache.make<string, A, E, R>({
        capacity: Number.POSITIVE_INFINITY,
        lookup: () =>
-          Effect.gen(function* () {
+          Effect.fnUntraced(function* () {
            return yield* init(yield* context)
-          }),
+          })(),
      })

      const off = registerDisposer((directory) => Effect.runPromise(ScopedCache.invalidate(cache, directory)))
@@ -5,6 +5,7 @@ import { AppFileSystem } from "@/filesystem"
 import { git } from "@/util/git"
 import { Effect, Layer, ServiceMap } from "effect"
 import { formatPatch, structuredPatch } from "diff"
+import fs from "fs"
 import fuzzysort from "fuzzysort"
 import ignore from "ignore"
 import path from "path"
@@ -358,46 +359,49 @@ export namespace File {
        const isGlobalHome = Instance.directory === Global.Path.home && Instance.project.id === "global"
        const next: Entry = { files: [], dirs: [] }

-        if (isGlobalHome) {
-          const dirs = new Set<string>()
-          const protectedNames = Protected.names()
-          const ignoreNested = new Set(["node_modules", "dist", "build", "target", "vendor"])
-          const shouldIgnoreName = (name: string) => name.startsWith(".") || protectedNames.has(name)
-          const shouldIgnoreNested = (name: string) => name.startsWith(".") || ignoreNested.has(name)
-          const top = yield* appFs.readDirectoryEntries(Instance.directory).pipe(Effect.orElseSucceed(() => []))
+        yield* Effect.promise(async () => {
+          if (isGlobalHome) {
+            const dirs = new Set<string>()
+            const protectedNames = Protected.names()
+            const ignoreNested = new Set(["node_modules", "dist", "build", "target", "vendor"])
+            const shouldIgnoreName = (name: string) => name.startsWith(".") || protectedNames.has(name)
+            const shouldIgnoreNested = (name: string) => name.startsWith(".") || ignoreNested.has(name)
+            const top = await fs.promises
+              .readdir(Instance.directory, { withFileTypes: true })
+              .catch(() => [] as fs.Dirent[])

-          for (const entry of top) {
-            if (entry.type !== "directory") continue
-            if (shouldIgnoreName(entry.name)) continue
-            dirs.add(entry.name + "/")
+            for (const entry of top) {
+              if (!entry.isDirectory()) continue
+              if (shouldIgnoreName(entry.name)) continue
+              dirs.add(entry.name + "/")

-            const base = path.join(Instance.directory, entry.name)
-            const children = yield* appFs.readDirectoryEntries(base).pipe(Effect.orElseSucceed(() => []))
-            for (const child of children) {
-              if (child.type !== "directory") continue
-              if (shouldIgnoreNested(child.name)) continue
-              dirs.add(entry.name + "/" + child.name + "/")
+              const base = path.join(Instance.directory, entry.name)
+              const children = await fs.promises.readdir(base, { withFileTypes: true }).catch(() => [] as fs.Dirent[])
+              for (const child of children) {
+                if (!child.isDirectory()) continue
+                if (shouldIgnoreNested(child.name)) continue
+                dirs.add(entry.name + "/" + child.name + "/")
+              }
+            }
+
+            next.dirs = Array.from(dirs).toSorted()
+          } else {
+            const seen = new Set<string>()
+            for await (const file of Ripgrep.files({ cwd: Instance.directory })) {
+              next.files.push(file)
+              let current = file
+              while (true) {
+                const dir = path.dirname(current)
+                if (dir === ".") break
+                if (dir === current) break
+                current = dir
+                if (seen.has(dir)) continue
+                seen.add(dir)
+                next.dirs.push(dir + "/")
+              }
            }
          }
-
-          next.dirs = Array.from(dirs).toSorted()
-        } else {
-          const files = yield* Effect.promise(() => Array.fromAsync(Ripgrep.files({ cwd: Instance.directory })))
-          const seen = new Set<string>()
-          for (const file of files) {
-            next.files.push(file)
-            let current = file
-            while (true) {
-              const dir = path.dirname(current)
-              if (dir === ".") break
-              if (dir === current) break
-              current = dir
-              if (seen.has(dir)) continue
-              seen.add(dir)
-              next.dirs.push(dir + "/")
-            }
-          }
-        }
+        })

        const s = yield* InstanceState.get(state)
        s.cache = next
@@ -632,27 +636,30 @@ export namespace File {
        yield* ensure()
        const { cache } = yield* InstanceState.get(state)

-        const query = input.query.trim()
-        const limit = input.limit ?? 100
-        const kind = input.type ?? (input.dirs === false ? "file" : "all")
-        log.info("search", { query, kind })
+        return yield* Effect.promise(async () => {
+          const query = input.query.trim()
+          const limit = input.limit ?? 100
+          const kind = input.type ?? (input.dirs === false ? "file" : "all")
+          log.info("search", { query, kind })

-        const preferHidden = query.startsWith(".") || query.includes("/.")
+          const result = cache
+          const preferHidden = query.startsWith(".") || query.includes("/.")

-        if (!query) {
-          if (kind === "file") return cache.files.slice(0, limit)
-          return sortHiddenLast(cache.dirs.toSorted(), preferHidden).slice(0, limit)
-        }
+          if (!query) {
+            if (kind === "file") return result.files.slice(0, limit)
+            return sortHiddenLast(result.dirs.toSorted(), preferHidden).slice(0, limit)
+          }

-        const items =
-          kind === "file" ? cache.files : kind === "directory" ? cache.dirs : [...cache.files, ...cache.dirs]
+          const items =
+            kind === "file" ? result.files : kind === "directory" ? result.dirs : [...result.files, ...result.dirs]

-        const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit
-        const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((item) => item.target)
-        const output = kind === "directory" ? sortHiddenLast(sorted, preferHidden).slice(0, limit) : sorted
+          const searchLimit = kind === "directory" && !preferHidden ? limit * 20 : limit
+          const sorted = fuzzysort.go(query, items, { limit: searchLimit }).map((item) => item.target)
+          const output = kind === "directory" ? sortHiddenLast(sorted, preferHidden).slice(0, limit) : sorted

-        log.info("search", { query, kind, results: output.length })
-        return output
+          log.info("search", { query, kind, results: output.length })
+          return output
+        })
      })

      log.info("init")
@@ -477,7 +477,7 @@ export namespace MCP {
        })
      }

-      const state = yield* InstanceState.make<State>(
+      const cache = yield* InstanceState.make<State>(
        Effect.fn("MCP.state")(function* () {
          const cfg = yield* cfgSvc.get()
          const config = cfg.mcp ?? {}
@@ -549,7 +549,7 @@ export namespace MCP {
      }

      const status = Effect.fn("MCP.status")(function* () {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)

        const cfg = yield* cfgSvc.get()
        const config = cfg.mcp ?? {}
@@ -564,12 +564,12 @@ export namespace MCP {
      })

      const clients = Effect.fn("MCP.clients")(function* () {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        return s.clients
      })

      const createAndStore = Effect.fn("MCP.createAndStore")(function* (name: string, mcp: Config.Mcp) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const result = yield* create(name, mcp)

        s.status[name] = result.status
@@ -588,7 +588,7 @@ export namespace MCP {

      const add = Effect.fn("MCP.add")(function* (name: string, mcp: Config.Mcp) {
        yield* createAndStore(name, mcp)
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        return { status: s.status }
      })

@@ -602,7 +602,7 @@ export namespace MCP {
      })

      const disconnect = Effect.fn("MCP.disconnect")(function* (name: string) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        yield* closeClient(s, name)
        delete s.clients[name]
        s.status[name] = { status: "disabled" }
@@ -610,7 +610,7 @@ export namespace MCP {

      const tools = Effect.fn("MCP.tools")(function* () {
        const result: Record<string, Tool> = {}
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)

        const cfg = yield* cfgSvc.get()
        const config = cfg.mcp ?? {}
@@ -657,12 +657,12 @@ export namespace MCP {
      }

      const prompts = Effect.fn("MCP.prompts")(function* () {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        return yield* collectFromConnected(s, (c) => c.listPrompts().then((r) => r.prompts), "prompts")
      })

      const resources = Effect.fn("MCP.resources")(function* () {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        return yield* collectFromConnected(s, (c) => c.listResources().then((r) => r.resources), "resources")
      })

@@ -672,7 +672,7 @@ export namespace MCP {
        label: string,
        meta?: Record<string, unknown>,
      ) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const client = s.clients[clientName]
        if (!client) {
          log.warn(`client not found for ${label}`, { clientName })
@@ -103,7 +103,7 @@ export namespace Plugin {
      const bus = yield* Bus.Service
      const config = yield* Config.Service

-      const state = yield* InstanceState.make<State>(
+      const cache = yield* InstanceState.make<State>(
        Effect.fn("Plugin.state")(function* (ctx) {
          const hooks: Hooks[] = []

@@ -279,8 +279,8 @@ export namespace Plugin {
        Output = Parameters<Required<Hooks>[Name]>[1],
      >(name: Name, input: Input, output: Output) {
        if (!name) return output
-        const s = yield* InstanceState.get(state)
-        for (const hook of s.hooks) {
+        const state = yield* InstanceState.get(cache)
+        for (const hook of state.hooks) {
          const fn = hook[name] as any
          if (!fn) continue
          yield* Effect.promise(async () => fn(input, output))
@@ -289,12 +289,12 @@ export namespace Plugin {
      })

      const list = Effect.fn("Plugin.list")(function* () {
-        const s = yield* InstanceState.get(state)
-        return s.hooks
+        const state = yield* InstanceState.get(cache)
+        return state.hooks
      })

      const init = Effect.fn("Plugin.init")(function* () {
-        yield* InstanceState.get(state)
+        yield* InstanceState.get(cache)
      })

      return Service.of({ trigger, list, init })
@@ -111,25 +111,26 @@ export namespace ProviderAuth {

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

-  export const layer: Layer.Layer<Service, never, Auth.Service | Plugin.Service> = Layer.effect(
+  export const layer = Layer.effect(
    Service,
    Effect.gen(function* () {
      const auth = yield* Auth.Service
-      const plugin = yield* Plugin.Service
      const state = yield* InstanceState.make<State>(
-        Effect.fn("ProviderAuth.state")(function* () {
-          const plugins = yield* plugin.list()
-          return {
-            hooks: Record.fromEntries(
-              Arr.filterMap(plugins, (x) =>
-                x.auth?.provider !== undefined
-                  ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
-                  : Result.failVoid,
+        Effect.fn("ProviderAuth.state")(() =>
+          Effect.promise(async () => {
+            const plugins = await Plugin.list()
+            return {
+              hooks: Record.fromEntries(
+                Arr.filterMap(plugins, (x) =>
+                  x.auth?.provider !== undefined
+                    ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
+                    : Result.failVoid,
+                ),
              ),
-            ),
-            pending: new Map<ProviderID, AuthOAuthResult>(),
-          }
-        }),
+              pending: new Map<ProviderID, AuthOAuthResult>(),
+            }
+          }),
+        ),
      )

      const methods = Effect.fn("ProviderAuth.methods")(function* () {
@@ -229,9 +230,7 @@ export namespace ProviderAuth {
    }),
  )

-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(Layer.provide(Auth.defaultLayer), Layer.provide(Plugin.defaultLayer)),
-  )
+  export const defaultLayer = layer.pipe(Layer.provide(Auth.defaultLayer))

  const { runPromise } = makeRuntime(Service, defaultLayer)

@@ -961,14 +961,13 @@ export namespace Provider {
    }
  }

-  const layer: Layer.Layer<Service, never, Config.Service | Auth.Service | Plugin.Service> = Layer.effect(
+  const layer: Layer.Layer<Service, never, Config.Service | Auth.Service> = Layer.effect(
    Service,
    Effect.gen(function* () {
      const config = yield* Config.Service
      const auth = yield* Auth.Service
-      const plugin = yield* Plugin.Service

-      const state = yield* InstanceState.make<State>(() =>
+      const cache = yield* InstanceState.make<State>(() =>
        Effect.gen(function* () {
          using _ = log.time("state")
          const cfg = yield* config.get()
@@ -1129,7 +1128,7 @@ export namespace Provider {
            }
          }

-          const plugins = yield* plugin.list()
+          const plugins = yield* Effect.promise(() => Plugin.list())
          for (const plugin of plugins) {
            if (!plugin.auth) continue
            const providerID = ProviderID.make(plugin.auth.provider)
@@ -1248,7 +1247,7 @@ export namespace Provider {
        }),
      )

-      const list = Effect.fn("Provider.list")(() => InstanceState.use(state, (s) => s.providers))
+      const list = Effect.fn("Provider.list")(() => InstanceState.use(cache, (s) => s.providers))

      async function resolveSDK(model: Model, s: State) {
        try {
@@ -1386,11 +1385,11 @@ export namespace Provider {
      }

      const getProvider = Effect.fn("Provider.getProvider")((providerID: ProviderID) =>
-        InstanceState.use(state, (s) => s.providers[providerID]),
+        InstanceState.use(cache, (s) => s.providers[providerID]),
      )

      const getModel = Effect.fn("Provider.getModel")(function* (providerID: ProviderID, modelID: ModelID) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const provider = s.providers[providerID]
        if (!provider) {
          const available = Object.keys(s.providers)
@@ -1408,7 +1407,7 @@ export namespace Provider {
      })

      const getLanguage = Effect.fn("Provider.getLanguage")(function* (model: Model) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const key = `${model.providerID}/${model.id}`
        if (s.models.has(key)) return s.models.get(key)!

@@ -1440,7 +1439,7 @@ export namespace Provider {
      })

      const closest = Effect.fn("Provider.closest")(function* (providerID: ProviderID, query: string[]) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const provider = s.providers[providerID]
        if (!provider) return undefined
        for (const item of query) {
@@ -1459,7 +1458,7 @@ export namespace Provider {
          return yield* getModel(parsed.providerID, parsed.modelID)
        }

-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const provider = s.providers[providerID]
        if (!provider) return undefined

@@ -1511,7 +1510,7 @@ export namespace Provider {
        const cfg = yield* config.get()
        if (cfg.model) return parseModel(cfg.model)

-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const recent = yield* Effect.promise(() =>
          Filesystem.readJson<{
            recent?: { providerID: ProviderID; modelID: ModelID }[]
@@ -1542,13 +1541,7 @@ export namespace Provider {
    }),
  )

-  export const defaultLayer = Layer.suspend(() =>
-    layer.pipe(
-      Layer.provide(Config.defaultLayer),
-      Layer.provide(Auth.defaultLayer),
-      Layer.provide(Plugin.defaultLayer),
-    ),
-  )
+  export const defaultLayer = layer.pipe(Layer.provide(Config.defaultLayer), Layer.provide(Auth.defaultLayer))

  const { runPromise } = makeRuntime(Service, defaultLayer)

@@ -130,7 +130,7 @@ export namespace Pty {
        session.subscribers.clear()
      }

-      const state = yield* InstanceState.make<State>(
+      const cache = yield* InstanceState.make<State>(
        Effect.fn("Pty.state")(function* (ctx) {
          const state = {
            dir: ctx.directory,
@@ -151,27 +151,27 @@ export namespace Pty {
      )

      const remove = Effect.fn("Pty.remove")(function* (id: PtyID) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
+        const state = yield* InstanceState.get(cache)
+        const session = state.sessions.get(id)
        if (!session) return
-        s.sessions.delete(id)
+        state.sessions.delete(id)
        log.info("removing session", { id })
        teardown(session)
        void Bus.publish(Event.Deleted, { id: session.info.id })
      })

      const list = Effect.fn("Pty.list")(function* () {
-        const s = yield* InstanceState.get(state)
-        return Array.from(s.sessions.values()).map((session) => session.info)
+        const state = yield* InstanceState.get(cache)
+        return Array.from(state.sessions.values()).map((session) => session.info)
      })

      const get = Effect.fn("Pty.get")(function* (id: PtyID) {
-        const s = yield* InstanceState.get(state)
-        return s.sessions.get(id)?.info
+        const state = yield* InstanceState.get(cache)
+        return state.sessions.get(id)?.info
      })

      const create = Effect.fn("Pty.create")(function* (input: CreateInput) {
-        const s = yield* InstanceState.get(state)
+        const state = yield* InstanceState.get(cache)
        return yield* Effect.promise(async () => {
          const id = PtyID.ascending()
          const command = input.command || Shell.preferred()
@@ -180,7 +180,7 @@ export namespace Pty {
            args.push("-l")
          }

-          const cwd = input.cwd || s.dir
+          const cwd = input.cwd || state.dir
          const shellEnv = await Plugin.trigger("shell.env", { cwd }, { env: {} })
          const env = {
            ...process.env,
@@ -221,7 +221,7 @@ export namespace Pty {
            cursor: 0,
            subscribers: new Map(),
          }
-          s.sessions.set(id, session)
+          state.sessions.set(id, session)
          proc.onData(
            Instance.bind((chunk) => {
              session.cursor += chunk.length
@@ -264,8 +264,8 @@ export namespace Pty {
      })

      const update = Effect.fn("Pty.update")(function* (id: PtyID, input: UpdateInput) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
+        const state = yield* InstanceState.get(cache)
+        const session = state.sessions.get(id)
        if (!session) return
        if (input.title) {
          session.info.title = input.title
@@ -278,24 +278,24 @@ export namespace Pty {
      })

      const resize = Effect.fn("Pty.resize")(function* (id: PtyID, cols: number, rows: number) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
+        const state = yield* InstanceState.get(cache)
+        const session = state.sessions.get(id)
        if (session && session.info.status === "running") {
          session.process.resize(cols, rows)
        }
      })

      const write = Effect.fn("Pty.write")(function* (id: PtyID, data: string) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
+        const state = yield* InstanceState.get(cache)
+        const session = state.sessions.get(id)
        if (session && session.info.status === "running") {
          session.process.write(data)
        }
      })

      const connect = Effect.fn("Pty.connect")(function* (id: PtyID, ws: Socket, cursor?: number) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
+        const state = yield* InstanceState.get(cache)
+        const session = state.sessions.get(id)
        if (!session) {
          ws.close()
          return
@@ -436,13 +436,13 @@ export const SessionRoutes = lazy(() =>
      validator(
        "param",
        z.object({
-          sessionID: SessionSummary.DiffInput.shape.sessionID,
+          sessionID: SessionSummary.diff.schema.shape.sessionID,
        }),
      ),
      validator(
        "query",
        z.object({
-          messageID: SessionSummary.DiffInput.shape.messageID,
+          messageID: SessionSummary.diff.schema.shape.messageID,
        }),
      ),
      async (c) => {
@@ -63,13 +63,7 @@ export namespace SessionCompaction {
  export const layer: Layer.Layer<
    Service,
    never,
-    | Bus.Service
-    | Config.Service
-    | Session.Service
-    | Agent.Service
-    | Plugin.Service
-    | SessionProcessor.Service
-    | Provider.Service
+    Bus.Service | Config.Service | Session.Service | Agent.Service | Plugin.Service | SessionProcessor.Service
  > = Layer.effect(
    Service,
    Effect.gen(function* () {
@@ -79,7 +73,6 @@ export namespace SessionCompaction {
      const agents = yield* Agent.Service
      const plugin = yield* Plugin.Service
      const processors = yield* SessionProcessor.Service
-      const provider = yield* Provider.Service

      const isOverflow = Effect.fn("SessionCompaction.isOverflow")(function* (input: {
        tokens: MessageV2.Assistant["tokens"]
@@ -177,9 +170,11 @@ export namespace SessionCompaction {
        }

        const agent = yield* agents.get("compaction")
-        const model = agent.model
-          ? yield* provider.getModel(agent.model.providerID, agent.model.modelID)
-          : yield* provider.getModel(userMessage.model.providerID, userMessage.model.modelID)
+        const model = yield* Effect.promise(() =>
+          agent.model
+            ? Provider.getModel(agent.model.providerID, agent.model.modelID)
+            : Provider.getModel(userMessage.model.providerID, userMessage.model.modelID),
+        )
        // Allow plugins to inject context or replace compaction prompt.
        const compacting = yield* plugin.trigger(
          "experimental.session.compacting",
@@ -382,7 +377,6 @@ When constructing the summary, try to stick to this template:
  export const defaultLayer = Layer.unwrap(
    Effect.sync(() =>
      layer.pipe(
-        Layer.provide(Provider.defaultLayer),
        Layer.provide(Session.defaultLayer),
        Layer.provide(SessionProcessor.defaultLayer),
        Layer.provide(Agent.defaultLayer),
@@ -294,10 +294,12 @@ export namespace SessionProcessor {
                }
                ctx.snapshot = undefined
              }
-              SessionSummary.summarize({
-                sessionID: ctx.sessionID,
-                messageID: ctx.assistantMessage.parentID,
-              })
+              yield* Effect.promise(() =>
+                SessionSummary.summarize({
+                  sessionID: ctx.sessionID,
+                  messageID: ctx.assistantMessage.parentID,
+                }),
+              ).pipe(Effect.ignoreCause({ log: true, message: "session summary failed" }), Effect.forkDetach)
              if (
                !ctx.assistantMessage.summary &&
                isOverflow({ cfg: yield* config.get(), tokens: usage.tokens, model: ctx.model })
@@ -28,9 +28,7 @@ import { ReadTool } from "../tool/read"
 import { FileTime } from "../file/time"
 import { Flag } from "../flag/flag"
 import { ulid } from "ulid"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
-import * as Stream from "effect/Stream"
+import { spawn } from "child_process"
 import { Command } from "../command"
 import { pathToFileURL, fileURLToPath } from "url"
 import { ConfigMarkdown } from "../config/markdown"
@@ -86,7 +84,6 @@ export namespace SessionPrompt {
      const status = yield* SessionStatus.Service
      const sessions = yield* Session.Service
      const agents = yield* Agent.Service
-      const provider = yield* Provider.Service
      const processor = yield* SessionProcessor.Service
      const compaction = yield* SessionCompaction.Service
      const plugin = yield* Plugin.Service
@@ -98,10 +95,9 @@ export namespace SessionPrompt {
      const filetime = yield* FileTime.Service
      const registry = yield* ToolRegistry.Service
      const truncate = yield* Truncate.Service
-      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
      const scope = yield* Scope.Scope

-      const state = yield* InstanceState.make(
+      const cache = yield* InstanceState.make(
        Effect.fn("SessionPrompt.state")(function* () {
          const runners = new Map<string, Runner<MessageV2.WithParts>>()
          yield* Effect.addFinalizer(
@@ -135,14 +131,14 @@ export namespace SessionPrompt {
      const assertNotBusy: (sessionID: SessionID) => Effect.Effect<void, Session.BusyError> = Effect.fn(
        "SessionPrompt.assertNotBusy",
      )(function* (sessionID: SessionID) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const runner = s.runners.get(sessionID)
        if (runner?.busy) throw new Session.BusyError(sessionID)
      })

      const cancel = Effect.fn("SessionPrompt.cancel")(function* (sessionID: SessionID) {
        log.info("cancel", { sessionID })
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const runner = s.runners.get(sessionID)
        if (!runner || !runner.busy) {
          yield* status.set(sessionID, { type: "idle" })
@@ -210,14 +206,14 @@ export namespace SessionPrompt {

        const ag = yield* agents.get("title")
        if (!ag) return
-        const mdl = ag.model
-          ? yield* provider.getModel(ag.model.providerID, ag.model.modelID)
-          : ((yield* provider.getSmallModel(input.providerID)) ??
-            (yield* provider.getModel(input.providerID, input.modelID)))
-        const msgs = onlySubtasks
-          ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
-          : yield* Effect.promise(() => MessageV2.toModelMessages(context, mdl))
        const text = yield* Effect.promise(async (signal) => {
+          const mdl = ag.model
+            ? await Provider.getModel(ag.model.providerID, ag.model.modelID)
+            : ((await Provider.getSmallModel(input.providerID)) ??
+              (await Provider.getModel(input.providerID, input.modelID)))
+          const msgs = onlySubtasks
+            ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
+            : await MessageV2.toModelMessages(context, mdl)
          const result = await LLM.stream({
            agent: ag,
            user: firstInfo,
@@ -812,26 +808,22 @@ NOTE: At any point in time through this workflow you should feel free to ask the
          fish: { args: ["-c", input.command] },
          zsh: {
            args: [
-              "-l",
              "-c",
+              "-l",
              `
-                __oc_cwd=$PWD
                [[ -f ~/.zshenv ]] && source ~/.zshenv >/dev/null 2>&1 || true
                [[ -f "\${ZDOTDIR:-$HOME}/.zshrc" ]] && source "\${ZDOTDIR:-$HOME}/.zshrc" >/dev/null 2>&1 || true
-                cd "$__oc_cwd"
                eval ${JSON.stringify(input.command)}
              `,
            ],
          },
          bash: {
            args: [
-              "-l",
              "-c",
+              "-l",
              `
-                __oc_cwd=$PWD
                shopt -s expand_aliases
                [[ -f ~/.bashrc ]] && source ~/.bashrc >/dev/null 2>&1 || true
-                cd "$__oc_cwd"
                eval ${JSON.stringify(input.command)}
              `,
            ],
@@ -839,7 +831,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
          cmd: { args: ["/c", input.command] },
          powershell: { args: ["-NoProfile", "-Command", input.command] },
          pwsh: { args: ["-NoProfile", "-Command", input.command] },
-          "": { args: ["-c", input.command] },
+          "": { args: ["-c", `${input.command}`] },
        }

        const args = (invocations[shellName] ?? invocations[""]).args
@@ -849,20 +841,51 @@ NOTE: At any point in time through this workflow you should feel free to ask the
          { cwd, sessionID: input.sessionID, callID: part.callID },
          { env: {} },
        )
-
-        const cmd = ChildProcess.make(sh, args, {
-          cwd,
-          extendEnv: true,
-          env: { ...shellEnv.env, TERM: "dumb" },
-          stdin: "ignore",
-          forceKillAfter: "3 seconds",
-        })
+        const proc = yield* Effect.sync(() =>
+          spawn(sh, args, {
+            cwd,
+            detached: process.platform !== "win32",
+            windowsHide: process.platform === "win32",
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+              ...process.env,
+              ...shellEnv.env,
+              TERM: "dumb",
+            },
+          }),
+        )

        let output = ""
+        const write = () => {
+          if (part.state.status !== "running") return
+          part.state.metadata = { output, description: "" }
+          void Effect.runFork(sessions.updatePart(part))
+        }
+
+        proc.stdout?.on("data", (chunk) => {
+          output += chunk.toString()
+          write()
+        })
+        proc.stderr?.on("data", (chunk) => {
+          output += chunk.toString()
+          write()
+        })
+
        let aborted = false
+        let exited = false
+        let finished = false
+        const kill = Effect.promise(() => Shell.killTree(proc, { exited: () => exited }))
+
+        const abortHandler = () => {
+          if (aborted) return
+          aborted = true
+          void Effect.runFork(kill)
+        }

        const finish = Effect.uninterruptible(
          Effect.gen(function* () {
+            if (finished) return
+            finished = true
            if (aborted) {
              output += "\n\n" + ["<metadata>", "User aborted the command", "</metadata>"].join("\n")
            }
@@ -884,26 +907,20 @@ NOTE: At any point in time through this workflow you should feel free to ask the
          }),
        )

-        const exit = yield* Effect.gen(function* () {
-          const handle = yield* spawner.spawn(cmd)
-          yield* Stream.runForEach(Stream.decodeText(handle.all), (chunk) =>
-            Effect.sync(() => {
-              output += chunk
-              if (part.state.status === "running") {
-                part.state.metadata = { output, description: "" }
-                void Effect.runFork(sessions.updatePart(part))
-              }
-            }),
-          )
-          yield* handle.exitCode
+        const exit = yield* Effect.promise(() => {
+          signal.addEventListener("abort", abortHandler, { once: true })
+          if (signal.aborted) abortHandler()
+          return new Promise<void>((resolve) => {
+            const close = () => {
+              exited = true
+              proc.off("close", close)
+              resolve()
+            }
+            proc.once("close", close)
+          })
        }).pipe(
-          Effect.scoped,
-          Effect.onInterrupt(() =>
-            Effect.sync(() => {
-              aborted = true
-            }),
-          ),
-          Effect.orDie,
+          Effect.onInterrupt(() => Effect.sync(abortHandler)),
+          Effect.ensuring(Effect.sync(() => signal.removeEventListener("abort", abortHandler))),
          Effect.ensuring(finish),
          Effect.exit,
        )
@@ -915,35 +932,21 @@ NOTE: At any point in time through this workflow you should feel free to ask the
        return { info: msg, parts: [part] }
      })

-      const getModel = Effect.fn("SessionPrompt.getModel")(function* (
-        providerID: ProviderID,
-        modelID: ModelID,
-        sessionID: SessionID,
-      ) {
-        const exit = yield* provider.getModel(providerID, modelID).pipe(Effect.exit)
-        if (Exit.isSuccess(exit)) return exit.value
-        const err = Cause.squash(exit.cause)
-        if (Provider.ModelNotFoundError.isInstance(err)) {
-          const hint = err.data.suggestions?.length ? ` Did you mean: ${err.data.suggestions.join(", ")}?` : ""
-          yield* bus.publish(Session.Event.Error, {
-            sessionID,
-            error: new NamedError.Unknown({
-              message: `Model not found: ${err.data.providerID}/${err.data.modelID}.${hint}`,
-            }).toObject(),
-          })
-        }
-        return yield* Effect.failCause(exit.cause)
-      })
-
-      const lastModel = Effect.fnUntraced(function* (sessionID: SessionID) {
-        const model = yield* Effect.promise(async () => {
-          for await (const item of MessageV2.stream(sessionID)) {
-            if (item.info.role === "user" && item.info.model) return item.info.model
-          }
-        })
-        if (model) return model
-        return yield* provider.defaultModel()
-      })
+      const getModel = (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) =>
+        Effect.promise(() =>
+          Provider.getModel(providerID, modelID).catch((e) => {
+            if (Provider.ModelNotFoundError.isInstance(e)) {
+              const hint = e.data.suggestions?.length ? ` Did you mean: ${e.data.suggestions.join(", ")}?` : ""
+              Bus.publish(Session.Event.Error, {
+                sessionID,
+                error: new NamedError.Unknown({
+                  message: `Model not found: ${e.data.providerID}/${e.data.modelID}.${hint}`,
+                }).toObject(),
+              })
+            }
+            throw e
+          }),
+        )

      const createUserMessage = Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
        const agentName = input.agent || (yield* agents.defaultAgent())
@@ -957,12 +960,9 @@ NOTE: At any point in time through this workflow you should feel free to ask the
        }

        const model = input.model ?? ag.model ?? (yield* lastModel(input.sessionID))
-        const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
        const full =
-          !input.variant && ag.variant && same
-            ? yield* provider
-                .getModel(model.providerID, model.modelID)
-                .pipe(Effect.catch(() => Effect.succeed(undefined)))
+          !input.variant && ag.variant
+            ? yield* Effect.promise(() => Provider.getModel(model.providerID, model.modelID).catch(() => undefined))
            : undefined
        const variant = input.variant ?? (ag.variant && full?.variants?.[ag.variant] ? ag.variant : undefined)

@@ -1109,7 +1109,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
                  ]
                  const read = yield* Effect.promise(() => ReadTool.init()).pipe(
                    Effect.flatMap((t) =>
-                      provider.getModel(info.model.providerID, info.model.modelID).pipe(
+                      Effect.promise(() => Provider.getModel(info.model.providerID, info.model.modelID)).pipe(
                        Effect.flatMap((mdl) =>
                          Effect.promise(() =>
                            t.execute(args, {
@@ -1557,14 +1557,14 @@ NOTE: At any point in time through this workflow you should feel free to ask the
      const loop: (input: z.infer<typeof LoopInput>) => Effect.Effect<MessageV2.WithParts> = Effect.fn(
        "SessionPrompt.loop",
      )(function* (input: z.infer<typeof LoopInput>) {
-        const s = yield* InstanceState.get(state)
+        const s = yield* InstanceState.get(cache)
        const runner = getRunner(s.runners, input.sessionID)
        return yield* runner.ensureRunning(runLoop(input.sessionID))
      })

      const shell: (input: ShellInput) => Effect.Effect<MessageV2.WithParts> = Effect.fn("SessionPrompt.shell")(
        function* (input: ShellInput) {
-          const s = yield* InstanceState.get(state)
+          const s = yield* InstanceState.get(cache)
          const runner = getRunner(s.runners, input.sessionID)
          return yield* runner.startShell((signal) => shellImpl(input, signal))
        },
@@ -1711,13 +1711,11 @@ NOTE: At any point in time through this workflow you should feel free to ask the
        Layer.provide(FileTime.defaultLayer),
        Layer.provide(ToolRegistry.defaultLayer),
        Layer.provide(Truncate.layer),
-        Layer.provide(Provider.defaultLayer),
        Layer.provide(AppFileSystem.defaultLayer),
        Layer.provide(Plugin.defaultLayer),
        Layer.provide(Session.defaultLayer),
        Layer.provide(Agent.defaultLayer),
        Layer.provide(Bus.layer),
-        Layer.provide(CrossSpawnSpawner.defaultLayer),
      ),
    ),
  )
@@ -1858,6 +1856,15 @@ NOTE: At any point in time through this workflow you should feel free to ask the
    return runPromise((svc) => svc.command(CommandInput.parse(input)))
  }

+  const lastModel = Effect.fnUntraced(function* (sessionID: SessionID) {
+    return yield* Effect.promise(async () => {
+      for await (const item of MessageV2.stream(sessionID)) {
+        if (item.info.role === "user" && item.info.model) return item.info.model
+      }
+      return Provider.defaultModel()
+    })
+  })
+
  /** @internal Exported for testing */
  export function createStructuredOutputTool(input: {
    schema: Record<string, any>
@@ -1,14 +1,12 @@
 import z from "zod"
-import { Effect, Layer, ServiceMap } from "effect"
-import { makeRuntime } from "@/effect/run-service"
-import { Bus } from "../bus"
-import { Snapshot } from "../snapshot"
-import { Storage } from "@/storage/storage"
-import { SyncEvent } from "../sync"
-import { Log } from "../util/log"
-import { Session } from "."
-import { MessageV2 } from "./message-v2"
 import { SessionID, MessageID, PartID } from "./schema"
+import { Snapshot } from "../snapshot"
+import { MessageV2 } from "./message-v2"
+import { Session } from "."
+import { Log } from "../util/log"
+import { SyncEvent } from "../sync"
+import { Storage } from "@/storage/storage"
+import { Bus } from "../bus"
 import { SessionPrompt } from "./prompt"
 import { SessionSummary } from "./summary"

@@ -22,152 +20,116 @@ export namespace SessionRevert {
  })
  export type RevertInput = z.infer<typeof RevertInput>

-  export interface Interface {
-    readonly revert: (input: RevertInput) => Effect.Effect<Session.Info>
-    readonly unrevert: (input: { sessionID: SessionID }) => Effect.Effect<Session.Info>
-    readonly cleanup: (session: Session.Info) => Effect.Effect<void>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionRevert") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const sessions = yield* Session.Service
-      const snap = yield* Snapshot.Service
-      const storage = yield* Storage.Service
-      const bus = yield* Bus.Service
-
-      const revert = Effect.fn("SessionRevert.revert")(function* (input: RevertInput) {
-        yield* Effect.promise(() => SessionPrompt.assertNotBusy(input.sessionID))
-        const all = yield* sessions.messages({ sessionID: input.sessionID })
-        let lastUser: MessageV2.User | undefined
-        const session = yield* sessions.get(input.sessionID)
-
-        let rev: Session.Info["revert"]
-        const patches: Snapshot.Patch[] = []
-        for (const msg of all) {
-          if (msg.info.role === "user") lastUser = msg.info
-          const remaining = []
-          for (const part of msg.parts) {
-            if (rev) {
-              if (part.type === "patch") patches.push(part)
-              continue
-            }
-
-            if (!rev) {
-              if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
-                const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
-                rev = {
-                  messageID: !partID && lastUser ? lastUser.id : msg.info.id,
-                  partID,
-                }
-              }
-              remaining.push(part)
-            }
-          }
-        }
-
-        if (!rev) return session
-
-        rev.snapshot = session.revert?.snapshot ?? (yield* snap.track())
-        yield* snap.revert(patches)
-        if (rev.snapshot) rev.diff = yield* snap.diff(rev.snapshot as string)
-        const range = all.filter((msg) => msg.info.id >= rev!.messageID)
-        const diffs = yield* Effect.promise(() => SessionSummary.computeDiff({ messages: range }))
-        yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
-        yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
-        yield* sessions.setRevert({
-          sessionID: input.sessionID,
-          revert: rev,
-          summary: {
-            additions: diffs.reduce((sum, x) => sum + x.additions, 0),
-            deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
-            files: diffs.length,
-          },
-        })
-        return yield* sessions.get(input.sessionID)
-      })
-
-      const unrevert = Effect.fn("SessionRevert.unrevert")(function* (input: { sessionID: SessionID }) {
-        log.info("unreverting", input)
-        yield* Effect.promise(() => SessionPrompt.assertNotBusy(input.sessionID))
-        const session = yield* sessions.get(input.sessionID)
-        if (!session.revert) return session
-        if (session.revert.snapshot) yield* snap.restore(session.revert!.snapshot!)
-        yield* sessions.clearRevert(input.sessionID)
-        return yield* sessions.get(input.sessionID)
-      })
-
-      const cleanup = Effect.fn("SessionRevert.cleanup")(function* (session: Session.Info) {
-        if (!session.revert) return
-        const sessionID = session.id
-        const msgs = yield* sessions.messages({ sessionID })
-        const messageID = session.revert.messageID
-        const remove = [] as MessageV2.WithParts[]
-        let target: MessageV2.WithParts | undefined
-        for (const msg of msgs) {
-          if (msg.info.id < messageID) continue
-          if (msg.info.id > messageID) {
-            remove.push(msg)
-            continue
-          }
-          if (session.revert.partID) {
-            target = msg
-            continue
-          }
-          remove.push(msg)
-        }
-        for (const msg of remove) {
-          SyncEvent.run(MessageV2.Event.Removed, {
-            sessionID,
-            messageID: msg.info.id,
-          })
-        }
-        if (session.revert.partID && target) {
-          const partID = session.revert.partID
-          const idx = target.parts.findIndex((part) => part.id === partID)
-          if (idx >= 0) {
-            const removeParts = target.parts.slice(idx)
-            target.parts = target.parts.slice(0, idx)
-            for (const part of removeParts) {
-              SyncEvent.run(MessageV2.Event.PartRemoved, {
-                sessionID,
-                messageID: target.info.id,
-                partID: part.id,
-              })
-            }
-          }
-        }
-        yield* sessions.clearRevert(sessionID)
-      })
-
-      return Service.of({ revert, unrevert, cleanup })
-    }),
-  )
-
-  export const defaultLayer = Layer.unwrap(
-    Effect.sync(() =>
-      layer.pipe(
-        Layer.provide(Session.defaultLayer),
-        Layer.provide(Snapshot.defaultLayer),
-        Layer.provide(Storage.defaultLayer),
-        Layer.provide(Bus.layer),
-      ),
-    ),
-  )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
  export async function revert(input: RevertInput) {
-    return runPromise((svc) => svc.revert(input))
+    await SessionPrompt.assertNotBusy(input.sessionID)
+    const all = await Session.messages({ sessionID: input.sessionID })
+    let lastUser: MessageV2.User | undefined
+    const session = await Session.get(input.sessionID)
+
+    let revert: Session.Info["revert"]
+    const patches: Snapshot.Patch[] = []
+    for (const msg of all) {
+      if (msg.info.role === "user") lastUser = msg.info
+      const remaining = []
+      for (const part of msg.parts) {
+        if (revert) {
+          if (part.type === "patch") {
+            patches.push(part)
+          }
+          continue
+        }
+
+        if (!revert) {
+          if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+            // if no useful parts left in message, same as reverting whole message
+            const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+            revert = {
+              messageID: !partID && lastUser ? lastUser.id : msg.info.id,
+              partID,
+            }
+          }
+          remaining.push(part)
+        }
+      }
+    }
+
+    if (revert) {
+      const session = await Session.get(input.sessionID)
+      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
+      await Snapshot.revert(patches)
+      if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
+      const rangeMessages = all.filter((msg) => msg.info.id >= revert!.messageID)
+      const diffs = await SessionSummary.computeDiff({ messages: rangeMessages })
+      await Storage.write(["session_diff", input.sessionID], diffs)
+      Bus.publish(Session.Event.Diff, {
+        sessionID: input.sessionID,
+        diff: diffs,
+      })
+      return Session.setRevert({
+        sessionID: input.sessionID,
+        revert,
+        summary: {
+          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+          files: diffs.length,
+        },
+      })
+    }
+    return session
  }

  export async function unrevert(input: { sessionID: SessionID }) {
-    return runPromise((svc) => svc.unrevert(input))
+    log.info("unreverting", input)
+    await SessionPrompt.assertNotBusy(input.sessionID)
+    const session = await Session.get(input.sessionID)
+    if (!session.revert) return session
+    if (session.revert.snapshot) await Snapshot.restore(session.revert.snapshot)
+    return Session.clearRevert(input.sessionID)
  }

  export async function cleanup(session: Session.Info) {
-    return runPromise((svc) => svc.cleanup(session))
+    if (!session.revert) return
+    const sessionID = session.id
+    const msgs = await Session.messages({ sessionID })
+    const messageID = session.revert.messageID
+    const remove = [] as MessageV2.WithParts[]
+    let target: MessageV2.WithParts | undefined
+    for (const msg of msgs) {
+      if (msg.info.id < messageID) {
+        continue
+      }
+      if (msg.info.id > messageID) {
+        remove.push(msg)
+        continue
+      }
+      if (session.revert.partID) {
+        target = msg
+        continue
+      }
+      remove.push(msg)
+    }
+    for (const msg of remove) {
+      SyncEvent.run(MessageV2.Event.Removed, {
+        sessionID: sessionID,
+        messageID: msg.info.id,
+      })
+    }
+    if (session.revert.partID && target) {
+      const partID = session.revert.partID
+      const removeStart = target.parts.findIndex((part) => part.id === partID)
+      if (removeStart >= 0) {
+        const preserveParts = target.parts.slice(0, removeStart)
+        const removeParts = target.parts.slice(removeStart)
+        target.parts = preserveParts
+        for (const part of removeParts) {
+          SyncEvent.run(MessageV2.Event.PartRemoved, {
+            sessionID: sessionID,
+            messageID: target.info.id,
+            partID: part.id,
+          })
+        }
+      }
+    }
+    await Session.clearRevert(sessionID)
  }
 }
@@ -1,12 +1,14 @@
+import { fn } from "@/util/fn"
 import z from "zod"
-import { Effect, Layer, ServiceMap } from "effect"
-import { makeRuntime } from "@/effect/run-service"
-import { Bus } from "@/bus"
-import { Snapshot } from "@/snapshot"
-import { Storage } from "@/storage/storage"
 import { Session } from "."
+
 import { MessageV2 } from "./message-v2"
 import { SessionID, MessageID } from "./schema"
+import { Snapshot } from "@/snapshot"
+
+import { Storage } from "@/storage/storage"
+import { Bus } from "@/bus"
+import { NotFoundError } from "@/storage/db"

 export namespace SessionSummary {
  function unquoteGitPath(input: string) {
@@ -65,113 +67,103 @@ export namespace SessionSummary {
    return Buffer.from(bytes).toString()
  }

-  export interface Interface {
-    readonly summarize: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<void>
-    readonly diff: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Snapshot.FileDiff[]>
-    readonly computeDiff: (input: { messages: MessageV2.WithParts[] }) => Effect.Effect<Snapshot.FileDiff[]>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/SessionSummary") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const sessions = yield* Session.Service
-      const snapshot = yield* Snapshot.Service
-      const storage = yield* Storage.Service
-      const bus = yield* Bus.Service
-
-      const computeDiff = Effect.fn("SessionSummary.computeDiff")(function* (input: {
-        messages: MessageV2.WithParts[]
-      }) {
-        let from: string | undefined
-        let to: string | undefined
-        for (const item of input.messages) {
-          if (!from) {
-            for (const part of item.parts) {
-              if (part.type === "step-start" && part.snapshot) {
-                from = part.snapshot
-                break
-              }
-            }
-          }
-          for (const part of item.parts) {
-            if (part.type === "step-finish" && part.snapshot) to = part.snapshot
-          }
-        }
-        if (from && to) return yield* snapshot.diffFull(from, to)
-        return []
-      })
-
-      const summarize = Effect.fn("SessionSummary.summarize")(function* (input: {
-        sessionID: SessionID
-        messageID: MessageID
-      }) {
-        const all = yield* sessions.messages({ sessionID: input.sessionID })
-        if (!all.length) return
-
-        const diffs = yield* computeDiff({ messages: all })
-        yield* sessions.setSummary({
-          sessionID: input.sessionID,
-          summary: {
-            additions: diffs.reduce((sum, x) => sum + x.additions, 0),
-            deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
-            files: diffs.length,
-          },
-        })
-        yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
-        yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
-
-        const messages = all.filter(
-          (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
-        )
-        const target = messages.find((m) => m.info.id === input.messageID)
-        if (!target || target.info.role !== "user") return
-        const msgDiffs = yield* computeDiff({ messages })
-        target.info.summary = { ...target.info.summary, diffs: msgDiffs }
-        yield* sessions.updateMessage(target.info)
-      })
-
-      const diff = Effect.fn("SessionSummary.diff")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
-        const diffs = yield* storage
-          .read<Snapshot.FileDiff[]>(["session_diff", input.sessionID])
-          .pipe(Effect.catch(() => Effect.succeed([] as Snapshot.FileDiff[])))
-        const next = diffs.map((item) => {
-          const file = unquoteGitPath(item.file)
-          if (file === item.file) return item
-          return { ...item, file }
-        })
-        const changed = next.some((item, i) => item.file !== diffs[i]?.file)
-        if (changed) yield* storage.write(["session_diff", input.sessionID], next).pipe(Effect.ignore)
-        return next
-      })
-
-      return Service.of({ summarize, diff, computeDiff })
+  export const summarize = fn(
+    z.object({
+      sessionID: SessionID.zod,
+      messageID: MessageID.zod,
    }),
+    async (input) => {
+      await Session.messages({ sessionID: input.sessionID })
+        .then((all) =>
+          Promise.all([
+            summarizeSession({ sessionID: input.sessionID, messages: all }),
+            summarizeMessage({ messageID: input.messageID, messages: all }),
+          ]),
+        )
+        .catch((err) => {
+          if (NotFoundError.isInstance(err)) return
+          throw err
+        })
+    },
  )

-  export const defaultLayer = layer.pipe(
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Snapshot.defaultLayer),
-    Layer.provide(Storage.defaultLayer),
-    Layer.provide(Bus.layer),
-  )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export const summarize = (input: { sessionID: SessionID; messageID: MessageID }) =>
-    void runPromise((svc) => svc.summarize(input)).catch(() => {})
-
-  export const DiffInput = z.object({
-    sessionID: SessionID.zod,
-    messageID: MessageID.zod.optional(),
-  })
-
-  export async function diff(input: z.infer<typeof DiffInput>) {
-    return runPromise((svc) => svc.diff(input))
+  async function summarizeSession(input: { sessionID: SessionID; messages: MessageV2.WithParts[] }) {
+    const diffs = await computeDiff({ messages: input.messages })
+    await Session.setSummary({
+      sessionID: input.sessionID,
+      summary: {
+        additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+        deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+        files: diffs.length,
+      },
+    })
+    await Storage.write(["session_diff", input.sessionID], diffs)
+    Bus.publish(Session.Event.Diff, {
+      sessionID: input.sessionID,
+      diff: diffs,
+    })
  }

+  async function summarizeMessage(input: { messageID: string; messages: MessageV2.WithParts[] }) {
+    const messages = input.messages.filter(
+      (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
+    )
+    const msgWithParts = messages.find((m) => m.info.id === input.messageID)
+    if (!msgWithParts || msgWithParts.info.role !== "user") return
+    const userMsg = msgWithParts.info
+    const diffs = await computeDiff({ messages })
+    userMsg.summary = {
+      ...userMsg.summary,
+      diffs,
+    }
+    await Session.updateMessage(userMsg)
+  }
+
+  export const diff = fn(
+    z.object({
+      sessionID: SessionID.zod,
+      messageID: MessageID.zod.optional(),
+    }),
+    async (input) => {
+      const diffs = await Storage.read<Snapshot.FileDiff[]>(["session_diff", input.sessionID]).catch(() => [])
+      const next = diffs.map((item) => {
+        const file = unquoteGitPath(item.file)
+        if (file === item.file) return item
+        return {
+          ...item,
+          file,
+        }
+      })
+      const changed = next.some((item, i) => item.file !== diffs[i]?.file)
+      if (changed) Storage.write(["session_diff", input.sessionID], next).catch(() => {})
+      return next
+    },
+  )
+
  export async function computeDiff(input: { messages: MessageV2.WithParts[] }) {
-    return runPromise((svc) => svc.computeDiff(input))
+    let from: string | undefined
+    let to: string | undefined
+
+    // scan assistant messages to find earliest from and latest to
+    // snapshot
+    for (const item of input.messages) {
+      if (!from) {
+        for (const part of item.parts) {
+          if (part.type === "step-start" && part.snapshot) {
+            from = part.snapshot
+            break
+          }
+        }
+      }
+
+      for (const part of item.parts) {
+        if (part.type === "step-finish" && part.snapshot) {
+          to = part.snapshot
+        }
+      }
+    }
+
+    if (from && to) return Snapshot.diffFull(from, to)
+    return []
  }
 }
@@ -57,7 +57,7 @@ export namespace ToolRegistry {
      const config = yield* Config.Service
      const plugin = yield* Plugin.Service

-      const state = yield* InstanceState.make<State>(
+      const cache = yield* InstanceState.make<State>(
        Effect.fn("ToolRegistry.state")(function* (ctx) {
          const custom: Tool.Info[] = []

@@ -139,18 +139,18 @@ export namespace ToolRegistry {
      })

      const register = Effect.fn("ToolRegistry.register")(function* (tool: Tool.Info) {
-        const s = yield* InstanceState.get(state)
-        const idx = s.custom.findIndex((t) => t.id === tool.id)
+        const state = yield* InstanceState.get(cache)
+        const idx = state.custom.findIndex((t) => t.id === tool.id)
        if (idx >= 0) {
-          s.custom.splice(idx, 1, tool)
+          state.custom.splice(idx, 1, tool)
          return
        }
-        s.custom.push(tool)
+        state.custom.push(tool)
      })

      const ids = Effect.fn("ToolRegistry.ids")(function* () {
-        const s = yield* InstanceState.get(state)
-        const tools = yield* all(s.custom)
+        const state = yield* InstanceState.get(cache)
+        const tools = yield* all(state.custom)
        return tools.map((t) => t.id)
      })

@@ -158,8 +158,8 @@ export namespace ToolRegistry {
        model: { providerID: ProviderID; modelID: ModelID },
        agent?: Agent.Info,
      ) {
-        const s = yield* InstanceState.get(state)
-        const allTools = yield* all(s.custom)
+        const state = yield* InstanceState.get(cache)
+        const allTools = yield* all(state.custom)
        const filtered = allTools.filter((tool) => {
          if (tool.id === "codesearch" || tool.id === "websearch") {
            return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA
@@ -148,70 +148,6 @@ it.live("token refresh persists the new token", () =>
  }),
 )

-it.live("concurrent config and token requests coalesce token refresh", () =>
-  Effect.gen(function* () {
-    const id = AccountID.make("user-1")
-
-    yield* AccountRepo.use((r) =>
-      r.persistAccount({
-        id,
-        email: "user@example.com",
-        url: "https://one.example.com",
-        accessToken: AccessToken.make("at_old"),
-        refreshToken: RefreshToken.make("rt_old"),
-        expiry: Date.now() - 1_000,
-        orgID: Option.some(OrgID.make("org-9")),
-      }),
-    )
-
-    let refreshCalls = 0
-    const client = HttpClient.make((req) =>
-      Effect.promise(async () => {
-        if (req.url === "https://one.example.com/auth/device/token") {
-          refreshCalls += 1
-
-          if (refreshCalls === 1) {
-            await new Promise((resolve) => setTimeout(resolve, 25))
-            return json(req, {
-              access_token: "at_new",
-              refresh_token: "rt_new",
-              expires_in: 60,
-            })
-          }
-
-          return json(
-            req,
-            {
-              error: "invalid_grant",
-              error_description: "refresh token already used",
-            },
-            400,
-          )
-        }
-
-        if (req.url === "https://one.example.com/api/config") {
-          return json(req, { config: { theme: "light", seats: 5 } })
-        }
-
-        return json(req, {}, 404)
-      }),
-    )
-
-    const [cfg, token] = yield* Account.Service.use((s) =>
-      Effect.all([s.config(id, OrgID.make("org-9")), s.token(id)], { concurrency: 2 }),
-    ).pipe(Effect.provide(live(client)))
-
-    expect(Option.getOrThrow(cfg)).toEqual({ theme: "light", seats: 5 })
-    expect(String(Option.getOrThrow(token))).toBe("at_new")
-    expect(refreshCalls).toBe(1)
-
-    const row = yield* AccountRepo.use((r) => r.getRow(id))
-    const value = Option.getOrThrow(row)
-    expect(value.access_token).toBe(AccessToken.make("at_new"))
-    expect(value.refresh_token).toBe(RefreshToken.make("rt_new"))
-  }),
-)
-
 it.live("config sends the selected org header", () =>
  Effect.gen(function* () {
    const id = AccountID.make("user-1")
@@ -1,47 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { expect, test } from "bun:test"
-import { createSlot, createSolidSlotRegistry, testRender, useRenderer } from "@opentui/solid"
-import { onMount } from "solid-js"
-
-type Slots = {
-  prompt: {}
-}
-
-test("replace slot mounts plugin content once", async () => {
-  let mounts = 0
-
-  const Probe = () => {
-    onMount(() => {
-      mounts += 1
-    })
-
-    return <box />
-  }
-
-  const App = () => {
-    const renderer = useRenderer()
-    const reg = createSolidSlotRegistry<Slots>(renderer, {})
-    const Slot = createSlot(reg)
-
-    reg.register({
-      id: "plugin",
-      slots: {
-        prompt() {
-          return <Probe />
-        },
-      },
-    })
-
-    return (
-      <box>
-        <Slot name="prompt" mode="replace">
-          <box />
-        </Slot>
-      </box>
-    )
-  }
-
-  await testRender(() => <App />)
-
-  expect(mounts).toBe(1)
-})
@@ -1,81 +0,0 @@
-import { Effect, Layer } from "effect"
-import { Provider } from "../../src/provider/provider"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-
-export namespace ProviderTest {
-  export function model(override: Partial<Provider.Model> = {}): Provider.Model {
-    const id = override.id ?? ModelID.make("gpt-5.2")
-    const providerID = override.providerID ?? ProviderID.make("openai")
-    return {
-      id,
-      providerID,
-      name: "Test Model",
-      capabilities: {
-        toolcall: true,
-        attachment: false,
-        reasoning: false,
-        temperature: true,
-        interleaved: false,
-        input: { text: true, image: false, audio: false, video: false, pdf: false },
-        output: { text: true, image: false, audio: false, video: false, pdf: false },
-      },
-      api: { id, url: "https://example.com", npm: "@ai-sdk/openai" },
-      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-      limit: { context: 200_000, output: 10_000 },
-      status: "active",
-      options: {},
-      headers: {},
-      release_date: "2025-01-01",
-      ...override,
-    }
-  }
-
-  export function info(override: Partial<Provider.Info> = {}, mdl = model()): Provider.Info {
-    const id = override.id ?? mdl.providerID
-    return {
-      id,
-      name: "Test Provider",
-      source: "config",
-      env: [],
-      options: {},
-      models: { [mdl.id]: mdl },
-      ...override,
-    }
-  }
-
-  export function fake(override: Partial<Provider.Interface> & { model?: Provider.Model; info?: Provider.Info } = {}) {
-    const mdl = override.model ?? model()
-    const row = override.info ?? info({}, mdl)
-    return {
-      model: mdl,
-      info: row,
-      layer: Layer.succeed(
-        Provider.Service,
-        Provider.Service.of({
-          list: Effect.fn("TestProvider.list")(() => Effect.succeed({ [row.id]: row })),
-          getProvider: Effect.fn("TestProvider.getProvider")((providerID) => {
-            if (providerID === row.id) return Effect.succeed(row)
-            return Effect.die(new Error(`Unknown test provider: ${providerID}`))
-          }),
-          getModel: Effect.fn("TestProvider.getModel")((providerID, modelID) => {
-            if (providerID === row.id && modelID === mdl.id) return Effect.succeed(mdl)
-            return Effect.die(new Error(`Unknown test model: ${providerID}/${modelID}`))
-          }),
-          getLanguage: Effect.fn("TestProvider.getLanguage")(() =>
-            Effect.die(new Error("ProviderTest.getLanguage not configured")),
-          ),
-          closest: Effect.fn("TestProvider.closest")((providerID) =>
-            Effect.succeed(providerID === row.id ? { providerID: row.id, modelID: mdl.id } : undefined),
-          ),
-          getSmallModel: Effect.fn("TestProvider.getSmallModel")((providerID) =>
-            Effect.succeed(providerID === row.id ? mdl : undefined),
-          ),
-          defaultModel: Effect.fn("TestProvider.defaultModel")(() =>
-            Effect.succeed({ providerID: row.id, modelID: mdl.id }),
-          ),
-          ...override,
-        }),
-      ),
-    }
-  }
-}
@@ -64,7 +64,9 @@ describe("Format", () => {
    ),
  )

-  it.live("service initializes without error", () => provideTmpdirInstance(() => Format.Service.use(() => Effect.void)))
+  it.live("service initializes without error", () =>
+    provideTmpdirInstance(() => Format.Service.use(() => Effect.void)),
+  )

  it.live("status() initializes formatter state per directory", () =>
    Effect.gen(function* () {
@@ -8,25 +8,11 @@ export type Usage = { input: number; output: number }

 type Line = Record<string, unknown>

-type Flow =
-  | { type: "text"; text: string }
-  | { type: "reason"; text: string }
-  | { type: "tool-start"; id: string; name: string }
-  | { type: "tool-args"; text: string }
-  | { type: "usage"; usage: Usage }
-
 type Hit = {
  url: URL
  body: Record<string, unknown>
 }

-type Match = (hit: Hit) => boolean
-
-type Queue = {
-  item: Item
-  match?: Match
-}
-
 type Wait = {
  count: number
  ready: Deferred.Deferred<void>
@@ -133,276 +119,6 @@ function bytes(input: Iterable<unknown>) {
  return Stream.fromIterable([...input].map(line)).pipe(Stream.encodeText)
 }

-function responseCreated(model: string) {
-  return {
-    type: "response.created",
-    sequence_number: 1,
-    response: {
-      id: "resp_test",
-      created_at: Math.floor(Date.now() / 1000),
-      model,
-      service_tier: null,
-    },
-  }
-}
-
-function responseCompleted(input: { seq: number; usage?: Usage }) {
-  return {
-    type: "response.completed",
-    sequence_number: input.seq,
-    response: {
-      incomplete_details: null,
-      service_tier: null,
-      usage: {
-        input_tokens: input.usage?.input ?? 0,
-        input_tokens_details: { cached_tokens: null },
-        output_tokens: input.usage?.output ?? 0,
-        output_tokens_details: { reasoning_tokens: null },
-      },
-    },
-  }
-}
-
-function responseMessage(id: string, seq: number) {
-  return {
-    type: "response.output_item.added",
-    sequence_number: seq,
-    output_index: 0,
-    item: { type: "message", id },
-  }
-}
-
-function responseText(id: string, text: string, seq: number) {
-  return {
-    type: "response.output_text.delta",
-    sequence_number: seq,
-    item_id: id,
-    delta: text,
-    logprobs: null,
-  }
-}
-
-function responseMessageDone(id: string, seq: number) {
-  return {
-    type: "response.output_item.done",
-    sequence_number: seq,
-    output_index: 0,
-    item: { type: "message", id },
-  }
-}
-
-function responseReason(id: string, seq: number) {
-  return {
-    type: "response.output_item.added",
-    sequence_number: seq,
-    output_index: 0,
-    item: { type: "reasoning", id, encrypted_content: null },
-  }
-}
-
-function responseReasonPart(id: string, seq: number) {
-  return {
-    type: "response.reasoning_summary_part.added",
-    sequence_number: seq,
-    item_id: id,
-    summary_index: 0,
-  }
-}
-
-function responseReasonText(id: string, text: string, seq: number) {
-  return {
-    type: "response.reasoning_summary_text.delta",
-    sequence_number: seq,
-    item_id: id,
-    summary_index: 0,
-    delta: text,
-  }
-}
-
-function responseReasonDone(id: string, seq: number) {
-  return {
-    type: "response.output_item.done",
-    sequence_number: seq,
-    output_index: 0,
-    item: { type: "reasoning", id, encrypted_content: null },
-  }
-}
-
-function responseTool(id: string, item: string, name: string, seq: number) {
-  return {
-    type: "response.output_item.added",
-    sequence_number: seq,
-    output_index: 0,
-    item: {
-      type: "function_call",
-      id: item,
-      call_id: id,
-      name,
-      arguments: "",
-      status: "in_progress",
-    },
-  }
-}
-
-function responseToolArgs(id: string, text: string, seq: number) {
-  return {
-    type: "response.function_call_arguments.delta",
-    sequence_number: seq,
-    output_index: 0,
-    item_id: id,
-    delta: text,
-  }
-}
-
-function responseToolDone(tool: { id: string; item: string; name: string; args: string }, seq: number) {
-  return {
-    type: "response.output_item.done",
-    sequence_number: seq,
-    output_index: 0,
-    item: {
-      type: "function_call",
-      id: tool.item,
-      call_id: tool.id,
-      name: tool.name,
-      arguments: tool.args,
-      status: "completed",
-    },
-  }
-}
-
-function choices(part: unknown) {
-  if (!part || typeof part !== "object") return
-  if (!("choices" in part) || !Array.isArray(part.choices)) return
-  const choice = part.choices[0]
-  if (!choice || typeof choice !== "object") return
-  return choice
-}
-
-function flow(item: Sse) {
-  const out: Flow[] = []
-  for (const part of [...item.head, ...item.tail]) {
-    const choice = choices(part)
-    const delta =
-      choice && "delta" in choice && choice.delta && typeof choice.delta === "object" ? choice.delta : undefined
-
-    if (delta && "content" in delta && typeof delta.content === "string") {
-      out.push({ type: "text", text: delta.content })
-    }
-
-    if (delta && "reasoning_content" in delta && typeof delta.reasoning_content === "string") {
-      out.push({ type: "reason", text: delta.reasoning_content })
-    }
-
-    if (delta && "tool_calls" in delta && Array.isArray(delta.tool_calls)) {
-      for (const tool of delta.tool_calls) {
-        if (!tool || typeof tool !== "object") continue
-        const fn = "function" in tool && tool.function && typeof tool.function === "object" ? tool.function : undefined
-        if ("id" in tool && typeof tool.id === "string" && fn && "name" in fn && typeof fn.name === "string") {
-          out.push({ type: "tool-start", id: tool.id, name: fn.name })
-        }
-        if (fn && "arguments" in fn && typeof fn.arguments === "string" && fn.arguments) {
-          out.push({ type: "tool-args", text: fn.arguments })
-        }
-      }
-    }
-
-    if (part && typeof part === "object" && "usage" in part && part.usage && typeof part.usage === "object") {
-      const raw = part.usage as Record<string, unknown>
-      if (typeof raw.prompt_tokens === "number" && typeof raw.completion_tokens === "number") {
-        out.push({
-          type: "usage",
-          usage: { input: raw.prompt_tokens, output: raw.completion_tokens },
-        })
-      }
-    }
-  }
-  return out
-}
-
-function responses(item: Sse, model: string) {
-  let seq = 1
-  let msg: string | undefined
-  let reason: string | undefined
-  let hasMsg = false
-  let hasReason = false
-  let call:
-    | {
-        id: string
-        item: string
-        name: string
-        args: string
-      }
-    | undefined
-  let usage: Usage | undefined
-  const lines: unknown[] = [responseCreated(model)]
-
-  for (const part of flow(item)) {
-    if (part.type === "text") {
-      msg ??= "msg_1"
-      if (!hasMsg) {
-        hasMsg = true
-        seq += 1
-        lines.push(responseMessage(msg, seq))
-      }
-      seq += 1
-      lines.push(responseText(msg, part.text, seq))
-      continue
-    }
-
-    if (part.type === "reason") {
-      reason ||= "rs_1"
-      if (!hasReason) {
-        hasReason = true
-        seq += 1
-        lines.push(responseReason(reason, seq))
-        seq += 1
-        lines.push(responseReasonPart(reason, seq))
-      }
-      seq += 1
-      lines.push(responseReasonText(reason, part.text, seq))
-      continue
-    }
-
-    if (part.type === "tool-start") {
-      call ||= { id: part.id, item: "fc_1", name: part.name, args: "" }
-      seq += 1
-      lines.push(responseTool(call.id, call.item, call.name, seq))
-      continue
-    }
-
-    if (part.type === "tool-args") {
-      if (!call) continue
-      call.args += part.text
-      seq += 1
-      lines.push(responseToolArgs(call.item, part.text, seq))
-      continue
-    }
-
-    usage = part.usage
-  }
-
-  if (msg) {
-    seq += 1
-    lines.push(responseMessageDone(msg, seq))
-  }
-  if (reason) {
-    seq += 1
-    lines.push(responseReasonDone(reason, seq))
-  }
-  if (call && !item.hang && !item.error) {
-    seq += 1
-    lines.push(responseToolDone(call, seq))
-  }
-  if (!item.hang && !item.error) lines.push(responseCompleted({ seq: seq + 1, usage }))
-  return { ...item, head: lines, tail: [] } satisfies Sse
-}
-
-function modelFrom(body: unknown) {
-  if (!body || typeof body !== "object") return "test-model"
-  if (!("model" in body) || typeof body.model !== "string") return "test-model"
-  return body.model
-}
-
 function send(item: Sse) {
  const head = bytes(item.head)
  const tail = bytes([...item.tail, ...(item.hang || item.error ? [] : [done])])
@@ -427,7 +143,7 @@ const reset = Effect.fn("TestLLMServer.reset")(function* (item: Sse) {
    for (const part of item.tail) res.write(line(part))
    res.destroy(new Error("connection reset"))
  })
-  return yield* Effect.never
+  yield* Effect.never
 })

 function fail(item: HttpError) {
@@ -577,20 +293,10 @@ function item(input: Item | Reply) {
  return input instanceof Reply ? input.item() : input
 }

-function hit(url: string, body: unknown) {
-  return {
-    url: new URL(url, "http://localhost"),
-    body: body && typeof body === "object" ? (body as Record<string, unknown>) : {},
-  } satisfies Hit
-}
-
 namespace TestLLMServer {
  export interface Service {
    readonly url: string
    readonly push: (...input: (Item | Reply)[]) => Effect.Effect<void>
-    readonly pushMatch: (match: Match, ...input: (Item | Reply)[]) => Effect.Effect<void>
-    readonly textMatch: (match: Match, value: string, opts?: { usage?: Usage }) => Effect.Effect<void>
-    readonly toolMatch: (match: Match, name: string, input: unknown) => Effect.Effect<void>
    readonly text: (value: string, opts?: { usage?: Usage }) => Effect.Effect<void>
    readonly tool: (name: string, input: unknown) => Effect.Effect<void>
    readonly toolHang: (name: string, input: unknown) => Effect.Effect<void>
@@ -615,15 +321,11 @@ export class TestLLMServer extends ServiceMap.Service<TestLLMServer, TestLLMServ
      const router = yield* HttpRouter.HttpRouter

      let hits: Hit[] = []
-      let list: Queue[] = []
+      let list: Item[] = []
      let waits: Wait[] = []

      const queue = (...input: (Item | Reply)[]) => {
-        list = [...list, ...input.map((value) => ({ item: item(value) }))]
-      }
-
-      const queueMatch = (match: Match, ...input: (Item | Reply)[]) => {
-        list = [...list, ...input.map((value) => ({ item: item(value), match }))]
+        list = [...list, ...input.map(item)]
      }

      const notify = Effect.fnUntraced(function* () {
@@ -633,33 +335,37 @@ export class TestLLMServer extends ServiceMap.Service<TestLLMServer, TestLLMServ
        yield* Effect.forEach(ready, (item) => Deferred.succeed(item.ready, void 0))
      })

-      const pull = (hit: Hit) => {
-        const index = list.findIndex((entry) => !entry.match || entry.match(hit))
-        if (index === -1) return
-        const first = list[index]
-        list = [...list.slice(0, index), ...list.slice(index + 1)]
-        return first.item
+      const pull = () => {
+        const first = list[0]
+        if (!first) return
+        list = list.slice(1)
+        return first
      }

-      const handle = Effect.fn("TestLLMServer.handle")(function* (mode: "chat" | "responses") {
-        const req = yield* HttpServerRequest.HttpServerRequest
-        const body = yield* req.json.pipe(Effect.orElseSucceed(() => ({})))
-        const current = hit(req.originalUrl, body)
-        const next = pull(current)
-        if (!next) return HttpServerResponse.text("unexpected request", { status: 500 })
-        hits = [...hits, current]
-        yield* notify()
-        if (next.type !== "sse") return fail(next)
-        if (mode === "responses") return send(responses(next, modelFrom(body)))
-        if (next.reset) {
-          yield* reset(next)
-          return HttpServerResponse.empty()
-        }
-        return send(next)
-      })
-
-      yield* router.add("POST", "/v1/chat/completions", handle("chat"))
-      yield* router.add("POST", "/v1/responses", handle("responses"))
+      yield* router.add(
+        "POST",
+        "/v1/chat/completions",
+        Effect.gen(function* () {
+          const req = yield* HttpServerRequest.HttpServerRequest
+          const next = pull()
+          if (!next) return HttpServerResponse.text("unexpected request", { status: 500 })
+          const body = yield* req.json.pipe(Effect.orElseSucceed(() => ({})))
+          hits = [
+            ...hits,
+            {
+              url: new URL(req.originalUrl, "http://localhost"),
+              body: body && typeof body === "object" ? (body as Record<string, unknown>) : {},
+            },
+          ]
+          yield* notify()
+          if (next.type === "sse" && next.reset) {
+            yield* reset(next)
+            return HttpServerResponse.empty()
+          }
+          if (next.type === "sse") return send(next)
+          return fail(next)
+        }),
+      )

      yield* server.serve(router.asHttpEffect())

@@ -671,21 +377,6 @@ export class TestLLMServer extends ServiceMap.Service<TestLLMServer, TestLLMServ
        push: Effect.fn("TestLLMServer.push")(function* (...input: (Item | Reply)[]) {
          queue(...input)
        }),
-        pushMatch: Effect.fn("TestLLMServer.pushMatch")(function* (match: Match, ...input: (Item | Reply)[]) {
-          queueMatch(match, ...input)
-        }),
-        textMatch: Effect.fn("TestLLMServer.textMatch")(function* (
-          match: Match,
-          value: string,
-          opts?: { usage?: Usage },
-        ) {
-          const out = reply().text(value)
-          if (opts?.usage) out.usage(opts.usage)
-          queueMatch(match, out.stop().item())
-        }),
-        toolMatch: Effect.fn("TestLLMServer.toolMatch")(function* (match: Match, name: string, input: unknown) {
-          queueMatch(match, reply().tool(name, input).item())
-        }),
        text: Effect.fn("TestLLMServer.text")(function* (value: string, opts?: { usage?: Usage }) {
          const out = reply().text(value)
          if (opts?.usage) out.usage(opts.usage)
@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, mock, test } from "bun:test"
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import { APICallError } from "ai"
 import { Cause, Effect, Exit, Layer, ManagedRuntime } from "effect"
 import * as Stream from "effect/Stream"
@@ -20,9 +20,9 @@ import { MessageID, PartID, SessionID } from "../../src/session/schema"
 import { SessionStatus } from "../../src/session/status"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import type { Provider } from "../../src/provider/provider"
+import * as ProviderModule from "../../src/provider/provider"
 import * as SessionProcessorModule from "../../src/session/processor"
 import { Snapshot } from "../../src/snapshot"
-import { ProviderTest } from "../fake/provider"

 Log.init({ print: false })

@@ -65,8 +65,6 @@ function createModel(opts: {
  } as Provider.Model
 }

-const wide = () => ProviderTest.fake({ model: createModel({ context: 100_000, output: 32_000 }) })
-
 async function user(sessionID: SessionID, text: string) {
  const msg = await Session.updateMessage({
    id: MessageID.ascending(),
@@ -164,11 +162,10 @@ function layer(result: "continue" | "compact") {
  )
 }

-function runtime(result: "continue" | "compact", plugin = Plugin.defaultLayer, provider = ProviderTest.fake()) {
+function runtime(result: "continue" | "compact", plugin = Plugin.defaultLayer) {
  const bus = Bus.layer
  return ManagedRuntime.make(
    Layer.mergeAll(SessionCompaction.layer, bus).pipe(
-      Layer.provide(provider.layer),
      Layer.provide(Session.defaultLayer),
      Layer.provide(layer(result)),
      Layer.provide(Agent.defaultLayer),
@@ -201,13 +198,12 @@ function llm() {
  }
 }

-function liveRuntime(layer: Layer.Layer<LLM.Service>, provider = ProviderTest.fake()) {
+function liveRuntime(layer: Layer.Layer<LLM.Service>) {
  const bus = Bus.layer
  const status = SessionStatus.layer.pipe(Layer.provide(bus))
  const processor = SessionProcessorModule.SessionProcessor.layer
  return ManagedRuntime.make(
    Layer.mergeAll(SessionCompaction.layer.pipe(Layer.provide(processor)), processor, bus, status).pipe(
-      Layer.provide(provider.layer),
      Layer.provide(Session.defaultLayer),
      Layer.provide(Snapshot.defaultLayer),
      Layer.provide(layer),
@@ -548,12 +544,14 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
        const msgs = await Session.messages({ sessionID: session.id })
        const done = defer()
        let seen = false
-        const rt = runtime("continue", Plugin.defaultLayer, wide())
+        const rt = runtime("continue")
        let unsub: (() => void) | undefined
        try {
          unsub = await rt.runPromise(
@@ -598,9 +596,11 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
-        const rt = runtime("compact", Plugin.defaultLayer, wide())
+        const rt = runtime("compact")
        try {
          const msgs = await Session.messages({ sessionID: session.id })
          const result = await rt.runPromise(
@@ -636,9 +636,11 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
-        const rt = runtime("continue", Plugin.defaultLayer, wide())
+        const rt = runtime("continue")
        try {
          const msgs = await Session.messages({ sessionID: session.id })
          const result = await rt.runPromise(
@@ -676,6 +678,8 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        await user(session.id, "root")
        const replay = await user(session.id, "image")
@@ -689,7 +693,7 @@ describe("session.compaction.process", () => {
          url: "https://example.com/cat.png",
        })
        const msg = await user(session.id, "current")
-        const rt = runtime("continue", Plugin.defaultLayer, wide())
+        const rt = runtime("continue")
        try {
          const msgs = await Session.messages({ sessionID: session.id })
          const result = await rt.runPromise(
@@ -724,11 +728,13 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        await user(session.id, "earlier")
        const msg = await user(session.id, "current")

-        const rt = runtime("continue", Plugin.defaultLayer, wide())
+        const rt = runtime("continue")
        try {
          const msgs = await Session.messages({ sessionID: session.id })
          const result = await rt.runPromise(
@@ -784,11 +790,13 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
        const msgs = await Session.messages({ sessionID: session.id })
        const abort = new AbortController()
-        const rt = liveRuntime(stub.layer, wide())
+        const rt = liveRuntime(stub.layer)
        let off: (() => void) | undefined
        let run: Promise<"continue" | "stop"> | undefined
        try {
@@ -858,11 +866,13 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
        const msgs = await Session.messages({ sessionID: session.id })
        const abort = new AbortController()
-        const rt = runtime("continue", plugin(ready), wide())
+        const rt = runtime("continue", plugin(ready))
        let run: Promise<"continue" | "stop"> | undefined
        try {
          run = rt
@@ -960,9 +970,11 @@ describe("session.compaction.process", () => {
    await Instance.provide({
      directory: tmp.path,
      fn: async () => {
+        spyOn(ProviderModule.Provider, "getModel").mockResolvedValue(createModel({ context: 100_000, output: 32_000 }))
+
        const session = await Session.create({})
        const msg = await user(session.id, "hello")
-        const rt = liveRuntime(stub.layer, wide())
+        const rt = liveRuntime(stub.layer)
        try {
          const msgs = await Session.messages({ sessionID: session.id })
          await rt.runPromise(
@@ -0,0 +1,247 @@
+import { describe, expect, spyOn, test } from "bun:test"
+import { Instance } from "../../src/project/instance"
+import { Provider } from "../../src/provider/provider"
+import { Session } from "../../src/session"
+import { MessageV2 } from "../../src/session/message-v2"
+import { SessionPrompt } from "../../src/session/prompt"
+import { SessionStatus } from "../../src/session/status"
+import { MessageID, PartID, SessionID } from "../../src/session/schema"
+import { Log } from "../../src/util/log"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+function deferred() {
+  let resolve!: () => void
+  const promise = new Promise<void>((done) => {
+    resolve = done
+  })
+  return { promise, resolve }
+}
+
+// Helper: seed a session with a user message + finished assistant message
+// so loop() exits immediately without calling any LLM
+async function seed(sessionID: SessionID) {
+  const userMsg: MessageV2.Info = {
+    id: MessageID.ascending(),
+    role: "user",
+    sessionID,
+    time: { created: Date.now() },
+    agent: "build",
+    model: { providerID: "openai" as any, modelID: "gpt-5.2" as any },
+  }
+  await Session.updateMessage(userMsg)
+  await Session.updatePart({
+    id: PartID.ascending(),
+    messageID: userMsg.id,
+    sessionID,
+    type: "text",
+    text: "hello",
+  })
+
+  const assistantMsg: MessageV2.Info = {
+    id: MessageID.ascending(),
+    role: "assistant",
+    parentID: userMsg.id,
+    sessionID,
+    mode: "build",
+    agent: "build",
+    cost: 0,
+    path: { cwd: "/tmp", root: "/tmp" },
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID: "gpt-5.2" as any,
+    providerID: "openai" as any,
+    time: { created: Date.now(), completed: Date.now() },
+    finish: "stop",
+  }
+  await Session.updateMessage(assistantMsg)
+  await Session.updatePart({
+    id: PartID.ascending(),
+    messageID: assistantMsg.id,
+    sessionID,
+    type: "text",
+    text: "hi there",
+  })
+
+  return { userMsg, assistantMsg }
+}
+
+describe("session.prompt concurrency", () => {
+  test("loop returns assistant message and sets status to idle", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        await seed(session.id)
+
+        const result = await SessionPrompt.loop({ sessionID: session.id })
+        expect(result.info.role).toBe("assistant")
+        if (result.info.role === "assistant") expect(result.info.finish).toBe("stop")
+
+        const status = await SessionStatus.get(session.id)
+        expect(status.type).toBe("idle")
+      },
+    })
+  })
+
+  test("concurrent loop callers get the same result", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        await seed(session.id)
+
+        const [a, b] = await Promise.all([
+          SessionPrompt.loop({ sessionID: session.id }),
+          SessionPrompt.loop({ sessionID: session.id }),
+        ])
+
+        expect(a.info.id).toBe(b.info.id)
+        expect(a.info.role).toBe("assistant")
+      },
+    })
+  })
+
+  test("assertNotBusy throws when loop is running", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        const userMsg: MessageV2.Info = {
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID: session.id,
+          time: { created: Date.now() },
+          agent: "build",
+          model: { providerID: "openai" as any, modelID: "gpt-5.2" as any },
+        }
+        await Session.updateMessage(userMsg)
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: userMsg.id,
+          sessionID: session.id,
+          type: "text",
+          text: "hello",
+        })
+
+        const ready = deferred()
+        const gate = deferred()
+        const getModel = spyOn(Provider, "getModel").mockImplementation(async () => {
+          ready.resolve()
+          await gate.promise
+          throw new Error("test stop")
+        })
+
+        try {
+          const loopPromise = SessionPrompt.loop({ sessionID: session.id }).catch(() => undefined)
+          await ready.promise
+
+          await expect(SessionPrompt.assertNotBusy(session.id)).rejects.toBeInstanceOf(Session.BusyError)
+
+          gate.resolve()
+          await loopPromise
+        } finally {
+          gate.resolve()
+          getModel.mockRestore()
+        }
+
+        // After loop completes, assertNotBusy should succeed
+        await SessionPrompt.assertNotBusy(session.id)
+      },
+    })
+  })
+
+  test("cancel sets status to idle", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        // Seed only a user message — loop must call getModel to proceed
+        const userMsg: MessageV2.Info = {
+          id: MessageID.ascending(),
+          role: "user",
+          sessionID: session.id,
+          time: { created: Date.now() },
+          agent: "build",
+          model: { providerID: "openai" as any, modelID: "gpt-5.2" as any },
+        }
+        await Session.updateMessage(userMsg)
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: userMsg.id,
+          sessionID: session.id,
+          type: "text",
+          text: "hello",
+        })
+        // Also seed an assistant message so lastAssistant() fallback can find it
+        const assistantMsg: MessageV2.Info = {
+          id: MessageID.ascending(),
+          role: "assistant",
+          parentID: userMsg.id,
+          sessionID: session.id,
+          mode: "build",
+          agent: "build",
+          cost: 0,
+          path: { cwd: "/tmp", root: "/tmp" },
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          modelID: "gpt-5.2" as any,
+          providerID: "openai" as any,
+          time: { created: Date.now() },
+        }
+        await Session.updateMessage(assistantMsg)
+        await Session.updatePart({
+          id: PartID.ascending(),
+          messageID: assistantMsg.id,
+          sessionID: session.id,
+          type: "text",
+          text: "hi there",
+        })
+
+        const ready = deferred()
+        const gate = deferred()
+        const getModel = spyOn(Provider, "getModel").mockImplementation(async () => {
+          ready.resolve()
+          await gate.promise
+          throw new Error("test stop")
+        })
+
+        try {
+          // Start loop — it will block in getModel (assistant has no finish, so loop continues)
+          const loopPromise = SessionPrompt.loop({ sessionID: session.id })
+
+          await ready.promise
+
+          await SessionPrompt.cancel(session.id)
+
+          const status = await SessionStatus.get(session.id)
+          expect(status.type).toBe("idle")
+
+          // loop should resolve cleanly, not throw "All fibers interrupted"
+          const result = await loopPromise
+          expect(result.info.role).toBe("assistant")
+          expect(result.info.id).toBe(assistantMsg.id)
+        } finally {
+          gate.resolve()
+          getModel.mockRestore()
+        }
+      },
+    })
+  }, 10000)
+
+  test("cancel on idle session just sets idle", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        await SessionPrompt.cancel(session.id)
+        const status = await SessionStatus.get(session.id)
+        expect(status.type).toBe("idle")
+      },
+    })
+  })
+})
@@ -1,7 +1,6 @@
 import { NodeFileSystem } from "@effect/platform-node"
 import { expect, spyOn } from "bun:test"
 import { Cause, Effect, Exit, Fiber, Layer } from "effect"
-import path from "path"
 import z from "zod"
 import type { Agent } from "../../src/agent/agent"
 import { Agent as AgentSvc } from "../../src/agent/agent"
@@ -13,7 +12,6 @@ import { LSP } from "../../src/lsp"
 import { MCP } from "../../src/mcp"
 import { Permission } from "../../src/permission"
 import { Plugin } from "../../src/plugin"
-import { Provider as ProviderSvc } from "../../src/provider/provider"
 import type { Provider } from "../../src/provider/provider"
 import { ModelID, ProviderID } from "../../src/provider/schema"
 import { Session } from "../../src/session"
@@ -153,7 +151,6 @@ function makeHttp() {
    Permission.layer,
    Plugin.defaultLayer,
    Config.defaultLayer,
-    ProviderSvc.defaultLayer,
    filetime,
    lsp,
    mcp,
@@ -888,79 +885,6 @@ unix("shell captures stdout and stderr in completed tool output", () =>
  ),
 )

-unix("shell completes a fast command on the preferred shell", () =>
-  provideTmpdirInstance(
-    (dir) =>
-      Effect.gen(function* () {
-        const { prompt, chat } = yield* boot()
-        const result = yield* prompt.shell({
-          sessionID: chat.id,
-          agent: "build",
-          command: "pwd",
-        })
-
-        expect(result.info.role).toBe("assistant")
-        const tool = completedTool(result.parts)
-        if (!tool) return
-
-        expect(tool.state.input.command).toBe("pwd")
-        expect(tool.state.output).toContain(dir)
-        expect(tool.state.metadata.output).toContain(dir)
-        yield* prompt.assertNotBusy(chat.id)
-      }),
-    { git: true, config: cfg },
-  ),
-)
-
-unix("shell lists files from the project directory", () =>
-  provideTmpdirInstance(
-    (dir) =>
-      Effect.gen(function* () {
-        const { prompt, chat } = yield* boot()
-        yield* Effect.promise(() => Bun.write(path.join(dir, "README.md"), "# e2e\n"))
-
-        const result = yield* prompt.shell({
-          sessionID: chat.id,
-          agent: "build",
-          command: "command ls",
-        })
-
-        expect(result.info.role).toBe("assistant")
-        const tool = completedTool(result.parts)
-        if (!tool) return
-
-        expect(tool.state.input.command).toBe("command ls")
-        expect(tool.state.output).toContain("README.md")
-        expect(tool.state.metadata.output).toContain("README.md")
-        yield* prompt.assertNotBusy(chat.id)
-      }),
-    { git: true, config: cfg },
-  ),
-)
-
-unix("shell captures stderr from a failing command", () =>
-  provideTmpdirInstance(
-    (dir) =>
-      Effect.gen(function* () {
-        const { prompt, chat } = yield* boot()
-        const result = yield* prompt.shell({
-          sessionID: chat.id,
-          agent: "build",
-          command: "command -v __nonexistent_cmd_e2e__ || echo 'not found' >&2; exit 1",
-        })
-
-        expect(result.info.role).toBe("assistant")
-        const tool = completedTool(result.parts)
-        if (!tool) return
-
-        expect(tool.state.output).toContain("not found")
-        expect(tool.state.metadata.output).toContain("not found")
-        yield* prompt.assertNotBusy(chat.id)
-      }),
-    { git: true, config: cfg },
-  ),
-)
-
 unix(
  "shell updates running metadata before process exit",
  () =>
@@ -10,66 +10,9 @@ import { Instance } from "../../src/project/instance"
 import { MessageID, PartID } from "../../src/session/schema"
 import { tmpdir } from "../fixture/fixture"

+const projectRoot = path.join(__dirname, "../..")
 Log.init({ print: false })

-function user(sessionID: string, agent = "default") {
-  return Session.updateMessage({
-    id: MessageID.ascending(),
-    role: "user" as const,
-    sessionID: sessionID as any,
-    agent,
-    model: { providerID: ProviderID.make("openai"), modelID: ModelID.make("gpt-4") },
-    time: { created: Date.now() },
-  })
-}
-
-function assistant(sessionID: string, parentID: string, dir: string) {
-  return Session.updateMessage({
-    id: MessageID.ascending(),
-    role: "assistant" as const,
-    sessionID: sessionID as any,
-    mode: "default",
-    agent: "default",
-    path: { cwd: dir, root: dir },
-    cost: 0,
-    tokens: { output: 0, input: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    modelID: ModelID.make("gpt-4"),
-    providerID: ProviderID.make("openai"),
-    parentID: parentID as any,
-    time: { created: Date.now() },
-    finish: "end_turn",
-  })
-}
-
-function text(sessionID: string, messageID: string, content: string) {
-  return Session.updatePart({
-    id: PartID.ascending(),
-    messageID: messageID as any,
-    sessionID: sessionID as any,
-    type: "text" as const,
-    text: content,
-  })
-}
-
-function tool(sessionID: string, messageID: string) {
-  return Session.updatePart({
-    id: PartID.ascending(),
-    messageID: messageID as any,
-    sessionID: sessionID as any,
-    type: "tool" as const,
-    tool: "bash",
-    callID: "call-1",
-    state: {
-      status: "completed" as const,
-      input: {},
-      output: "done",
-      title: "",
-      metadata: {},
-      time: { start: 0, end: 1 },
-    },
-  })
-}
-
 describe("revert + compact workflow", () => {
  test("should properly handle compact command after revert", async () => {
    await using tmp = await tmpdir({ git: true })
@@ -340,98 +283,4 @@ describe("revert + compact workflow", () => {
      },
    })
  })
-
-  test("cleanup with partID removes parts from the revert point onward", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-        const sid = session.id
-
-        const u1 = await user(sid)
-        const p1 = await text(sid, u1.id, "first part")
-        const p2 = await tool(sid, u1.id)
-        const p3 = await text(sid, u1.id, "third part")
-
-        // Set revert state pointing at a specific part
-        await Session.setRevert({
-          sessionID: sid,
-          revert: { messageID: u1.id, partID: p2.id },
-          summary: { additions: 0, deletions: 0, files: 0 },
-        })
-
-        const info = await Session.get(sid)
-        await SessionRevert.cleanup(info)
-
-        const msgs = await Session.messages({ sessionID: sid })
-        expect(msgs.length).toBe(1)
-        // Only the first part should remain (before the revert partID)
-        expect(msgs[0].parts.length).toBe(1)
-        expect(msgs[0].parts[0].id).toBe(p1.id)
-
-        const cleared = await Session.get(sid)
-        expect(cleared.revert).toBeUndefined()
-      },
-    })
-  })
-
-  test("cleanup removes messages after revert point but keeps earlier ones", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-        const sid = session.id
-
-        const u1 = await user(sid)
-        await text(sid, u1.id, "hello")
-        const a1 = await assistant(sid, u1.id, tmp.path)
-        await text(sid, a1.id, "hi back")
-
-        const u2 = await user(sid)
-        await text(sid, u2.id, "second question")
-        const a2 = await assistant(sid, u2.id, tmp.path)
-        await text(sid, a2.id, "second answer")
-
-        // Revert from u2 onward
-        await Session.setRevert({
-          sessionID: sid,
-          revert: { messageID: u2.id },
-          summary: { additions: 0, deletions: 0, files: 0 },
-        })
-
-        const info = await Session.get(sid)
-        await SessionRevert.cleanup(info)
-
-        const msgs = await Session.messages({ sessionID: sid })
-        const ids = msgs.map((m) => m.info.id)
-        expect(ids).toContain(u1.id)
-        expect(ids).toContain(a1.id)
-        expect(ids).not.toContain(u2.id)
-        expect(ids).not.toContain(a2.id)
-      },
-    })
-  })
-
-  test("cleanup is a no-op when session has no revert state", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({})
-        const sid = session.id
-
-        const u1 = await user(sid)
-        await text(sid, u1.id, "hello")
-
-        const info = await Session.get(sid)
-        expect(info.revert).toBeUndefined()
-        await SessionRevert.cleanup(info)
-
-        const msgs = await Session.messages({ sessionID: sid })
-        expect(msgs.length).toBe(1)
-      },
-    })
-  })
 })
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/plugin",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -21,8 +21,8 @@
    "zod": "catalog:"
  },
  "peerDependencies": {
-    "@opentui/core": ">=0.1.95",
-    "@opentui/solid": ">=0.1.95"
+    "@opentui/core": ">=0.1.93",
+    "@opentui/solid": ">=0.1.93"
  },
  "peerDependenciesMeta": {
    "@opentui/core": {
@@ -33,8 +33,8 @@
    }
  },
  "devDependencies": {
-    "@opentui/core": "0.1.95",
-    "@opentui/solid": "0.1.95",
+    "@opentui/core": "0.1.93",
+    "@opentui/solid": "0.1.93",
    "@tsconfig/node22": "catalog:",
    "@types/node": "catalog:",
    "typescript": "catalog:",
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode-ai/sdk",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -7040,6 +7040,44 @@
  },
  "components": {
    "schemas": {
+      "Event.installation.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "installation.updated"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "version": {
+                "type": "string"
+              }
+            },
+            "required": ["version"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
+      "Event.installation.update-available": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "installation.update-available"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "version": {
+                "type": "string"
+              }
+            },
+            "required": ["version"]
+          }
+        },
+        "required": ["type", "properties"]
+      },
      "Project": {
        "type": "object",
        "properties": {
@@ -7116,44 +7154,6 @@
        },
        "required": ["type", "properties"]
      },
-      "Event.installation.updated": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "installation.updated"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "version": {
-                "type": "string"
-              }
-            },
-            "required": ["version"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
-      "Event.installation.update-available": {
-        "type": "object",
-        "properties": {
-          "type": {
-            "type": "string",
-            "const": "installation.update-available"
-          },
-          "properties": {
-            "type": "object",
-            "properties": {
-              "version": {
-                "type": "string"
-              }
-            },
-            "required": ["version"]
-          }
-        },
-        "required": ["type", "properties"]
-      },
      "Event.server.instance.disposed": {
        "type": "object",
        "properties": {
@@ -9733,15 +9733,15 @@
      },
      "Event": {
        "anyOf": [
-          {
-            "$ref": "#/components/schemas/Event.project.updated"
-          },
          {
            "$ref": "#/components/schemas/Event.installation.updated"
          },
          {
            "$ref": "#/components/schemas/Event.installation.update-available"
          },
+          {
+            "$ref": "#/components/schemas/Event.project.updated"
+          },
          {
            "$ref": "#/components/schemas/Event.server.instance.disposed"
          },
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/slack",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/ui",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "type": "module",
  "license": "MIT",
  "exports": {
@@ -7,12 +7,11 @@ export function DockPrompt(props: {
  children: JSX.Element
  footer: JSX.Element
  ref?: (el: HTMLDivElement) => void
-  onKeyDown?: JSX.EventHandlerUnion<HTMLDivElement, KeyboardEvent>
 }) {
  const slot = (name: string) => `${props.kind}-${name}`

  return (
-    <div data-component="dock-prompt" data-kind={props.kind} ref={props.ref} onKeyDown={props.onKeyDown}>
+    <div data-component="dock-prompt" data-kind={props.kind} ref={props.ref}>
      <DockShell data-slot={slot("body")}>
        <div data-slot={slot("header")}>{props.header}</div>
        <div data-slot={slot("content")}>{props.children}</div>
@@ -5,7 +5,7 @@ import { render as renderSolid } from "solid-js/web"
 import { useI18n } from "../context/i18n"
 import { createHoverCommentUtility } from "../pierre/comment-hover"
 import { cloneSelectedLineRange, formatSelectedLineLabel, lineInSelectedRange } from "../pierre/selection-bridge"
-import { LineComment, LineCommentEditor, type LineCommentEditorProps } from "./line-comment"
+import { LineComment, LineCommentEditor } from "./line-comment"

 export type LineCommentAnnotationMeta<T> =
  | { kind: "comment"; key: string; comment: T }
@@ -55,7 +55,6 @@ type LineCommentControllerProps<T extends LineCommentShape> = {
  comments: Accessor<T[]>
  draftKey: Accessor<string>
  label: string
-  mention?: LineCommentEditorProps["mention"]
  state: LineCommentStateProps<string>
  onSubmit: (input: { comment: string; selection: SelectedLineRange }) => void
  onUpdate?: (input: { id: string; comment: string; selection: SelectedLineRange }) => void
@@ -86,7 +85,6 @@ type CommentProps = {
 type DraftProps = {
  value: string
  selection: JSX.Element
-  mention?: LineCommentEditorProps["mention"]
  onInput: (value: string) => void
  onCancel: VoidFunction
  onSubmit: (value: string) => void
@@ -150,7 +148,6 @@ export function createLineCommentAnnotationRenderer<T>(props: {
              onPopoverFocusOut={view().editor!.onPopoverFocusOut}
              cancelLabel={view().editor!.cancelLabel}
              submitLabel={view().editor!.submitLabel}
-              mention={view().editor!.mention}
            />
          </Show>
        )
@@ -170,7 +167,6 @@ export function createLineCommentAnnotationRenderer<T>(props: {
          onCancel={view().onCancel}
          onSubmit={view().onSubmit}
          onPopoverFocusOut={view().onPopoverFocusOut}
-          mention={view().mention}
        />
      )
    }, host)
@@ -393,7 +389,6 @@ export function createLineCommentController<T extends LineCommentShape>(
                  return note.draft()
                },
                selection: formatSelectedLineLabel(comment.selection, i18n.t),
-                mention: props.mention,
                onInput: note.setDraft,
                onCancel: note.cancelDraft,
                onSubmit: (value: string) => {
@@ -420,7 +415,6 @@ export function createLineCommentController<T extends LineCommentShape>(
        return note.draft()
      },
      selection: formatSelectedLineLabel(range, i18n.t),
-      mention: props.mention,
      onInput: note.setDraft,
      onCancel: note.cancelDraft,
      onSubmit: (comment) => {
@@ -178,58 +178,6 @@ export const lineCommentStyles = `
  box-shadow: var(--shadow-xs-border-select);
 }

-[data-component="line-comment"] [data-slot="line-comment-mention-list"] {
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  max-height: 180px;
-  overflow: auto;
-  padding: 4px;
-  border: 1px solid var(--border-base);
-  border-radius: var(--radius-md);
-  background: var(--surface-base);
-}
-
-[data-component="line-comment"] [data-slot="line-comment-mention-item"] {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  width: 100%;
-  min-width: 0;
-  padding: 6px 8px;
-  border: 0;
-  border-radius: var(--radius-sm);
-  background: transparent;
-  color: var(--text-strong);
-  text-align: left;
-}
-
-[data-component="line-comment"] [data-slot="line-comment-mention-item"][data-active] {
-  background: var(--surface-raised-base-hover);
-}
-
-[data-component="line-comment"] [data-slot="line-comment-mention-path"] {
-  display: flex;
-  align-items: center;
-  min-width: 0;
-  font-family: var(--font-family-sans);
-  font-size: var(--font-size-small);
-  line-height: var(--line-height-large);
-}
-
-[data-component="line-comment"] [data-slot="line-comment-mention-dir"] {
-  min-width: 0;
-  color: var(--text-weak);
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-[data-component="line-comment"] [data-slot="line-comment-mention-file"] {
-  color: var(--text-strong);
-  white-space: nowrap;
-}
-
 [data-component="line-comment"] [data-slot="line-comment-actions"] {
  display: flex;
  align-items: center;
@@ -1,8 +1,5 @@
-import { useFilteredList } from "@opencode-ai/ui/hooks"
-import { getDirectory, getFilename } from "@opencode-ai/util/path"
-import { createEffect, createSignal, For, onMount, Show, splitProps, type JSX } from "solid-js"
+import { createEffect, createSignal, onMount, Show, splitProps, type JSX } from "solid-js"
 import { Button } from "./button"
-import { FileIcon } from "./file-icon"
 import { Icon } from "./icon"
 import { installLineCommentStyles } from "./line-comment-styles"
 import { useI18n } from "../context/i18n"
@@ -186,9 +183,6 @@ export type LineCommentEditorProps = Omit<LineCommentAnchorProps, "children" | "
  autofocus?: boolean
  cancelLabel?: string
  submitLabel?: string
-  mention?: {
-    items: (query: string) => string[] | Promise<string[]>
-  }
 }

 export const LineCommentEditor = (props: LineCommentEditorProps) => {
@@ -204,46 +198,12 @@ export const LineCommentEditor = (props: LineCommentEditorProps) => {
    "autofocus",
    "cancelLabel",
    "submitLabel",
-    "mention",
  ])

  const refs = {
    textarea: undefined as HTMLTextAreaElement | undefined,
  }
  const [text, setText] = createSignal(split.value)
-  const [open, setOpen] = createSignal(false)
-
-  function selectMention(item: { path: string } | undefined) {
-    if (!item) return
-
-    const textarea = refs.textarea
-    const query = currentMention()
-    if (!textarea || !query) return
-
-    const value = `${text().slice(0, query.start)}@${item.path} ${text().slice(query.end)}`
-    const cursor = query.start + item.path.length + 2
-
-    setText(value)
-    split.onInput(value)
-    closeMention()
-
-    requestAnimationFrame(() => {
-      textarea.focus()
-      textarea.setSelectionRange(cursor, cursor)
-    })
-  }
-
-  const mention = useFilteredList<{ path: string }>({
-    items: async (query) => {
-      if (!split.mention) return []
-      if (!query.trim()) return []
-      const paths = await split.mention.items(query)
-      return paths.map((path) => ({ path }))
-    },
-    key: (item) => item.path,
-    filterKeys: ["path"],
-    onSelect: selectMention,
-  })

  const focus = () => refs.textarea?.focus()
  const hold: JSX.EventHandlerUnion<HTMLButtonElement, MouseEvent> = (e) => {
@@ -261,46 +221,6 @@ export const LineCommentEditor = (props: LineCommentEditorProps) => {
    setText(split.value)
  })

-  const closeMention = () => {
-    setOpen(false)
-    mention.clear()
-  }
-
-  const currentMention = () => {
-    const textarea = refs.textarea
-    if (!textarea) return
-    if (!split.mention) return
-    if (textarea.selectionStart !== textarea.selectionEnd) return
-
-    const end = textarea.selectionStart
-    const match = textarea.value.slice(0, end).match(/@(\S*)$/)
-    if (!match) return
-
-    return {
-      query: match[1] ?? "",
-      start: end - match[0].length,
-      end,
-    }
-  }
-
-  const syncMention = () => {
-    const item = currentMention()
-    if (!item) {
-      closeMention()
-      return
-    }
-
-    setOpen(true)
-    mention.onInput(item.query)
-  }
-
-  const selectActiveMention = () => {
-    const items = mention.flat()
-    if (items.length === 0) return
-    const active = mention.active()
-    selectMention(items.find((item) => item.path === active) ?? items[0])
-  }
-
  const submit = () => {
    const value = text().trim()
    if (!value) return
@@ -327,38 +247,11 @@ export const LineCommentEditor = (props: LineCommentEditorProps) => {
            const value = (e.currentTarget as HTMLTextAreaElement).value
            setText(value)
            split.onInput(value)
-            syncMention()
          }}
-          on:click={() => syncMention()}
-          on:select={() => syncMention()}
          on:keydown={(e) => {
            const event = e as KeyboardEvent
            if (event.isComposing || event.keyCode === 229) return
            event.stopPropagation()
-            if (open()) {
-              if (e.key === "Escape") {
-                event.preventDefault()
-                closeMention()
-                return
-              }
-
-              if (e.key === "Tab") {
-                if (mention.flat().length === 0) return
-                event.preventDefault()
-                selectActiveMention()
-                return
-              }
-
-              const nav = e.key === "ArrowUp" || e.key === "ArrowDown" || e.key === "Enter"
-              const ctrlNav =
-                event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey && (e.key === "n" || e.key === "p")
-              if ((nav || ctrlNav) && mention.flat().length > 0) {
-                mention.onKeyDown(event)
-                event.preventDefault()
-                return
-              }
-            }
-
            if (e.key === "Escape") {
              event.preventDefault()
              e.currentTarget.blur()
@@ -371,34 +264,6 @@ export const LineCommentEditor = (props: LineCommentEditorProps) => {
            submit()
          }}
        />
-        <Show when={open() && mention.flat().length > 0}>
-          <div data-slot="line-comment-mention-list">
-            <For each={mention.flat().slice(0, 10)}>
-              {(item) => {
-                const directory = item.path.endsWith("/") ? item.path : getDirectory(item.path)
-                const name = item.path.endsWith("/") ? "" : getFilename(item.path)
-                return (
-                  <button
-                    type="button"
-                    data-slot="line-comment-mention-item"
-                    data-active={mention.active() === item.path ? "" : undefined}
-                    onMouseDown={(event) => event.preventDefault()}
-                    onMouseEnter={() => mention.setActive(item.path)}
-                    onClick={() => selectMention(item)}
-                  >
-                    <FileIcon node={{ path: item.path, type: "file" }} class="shrink-0 size-4" />
-                    <div data-slot="line-comment-mention-path">
-                      <span data-slot="line-comment-mention-dir">{directory}</span>
-                      <Show when={name}>
-                        <span data-slot="line-comment-mention-file">{name}</span>
-                      </Show>
-                    </div>
-                  </button>
-                )
-              }}
-            </For>
-          </div>
-        </Show>
        <div data-slot="line-comment-actions">
          <div data-slot="line-comment-editor-label">
            {i18n.t("ui.lineComment.editorLabel.prefix")}
@@ -13,7 +13,8 @@ import { useFileComponent } from "../context/file"
 import { useI18n } from "../context/i18n"
 import { getDirectory, getFilename } from "@opencode-ai/util/path"
 import { checksum } from "@opencode-ai/util/encode"
-import { createEffect, createMemo, For, Match, onCleanup, Show, Switch, untrack, type JSX } from "solid-js"
+import { createEffect, createMemo, For, Match, Show, Switch, untrack, type JSX } from "solid-js"
+import { onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { type FileContent, type FileDiff } from "@opencode-ai/sdk/v2"
 import { PreloadMultiFileDiffResult } from "@pierre/diffs/ssr"
@@ -22,10 +23,8 @@ import { Dynamic } from "solid-js/web"
 import { mediaKindFromPath } from "../pierre/media"
 import { cloneSelectedLineRange, previewSelectedLines } from "../pierre/selection-bridge"
 import { createLineCommentController } from "./line-comment-annotations"
-import type { LineCommentEditorProps } from "./line-comment"

 const MAX_DIFF_CHANGED_LINES = 500
-const REVIEW_MOUNT_MARGIN = 300

 export type SessionReviewDiffStyle = "unified" | "split"

@@ -69,7 +68,7 @@ export interface SessionReviewProps {
  split?: boolean
  diffStyle?: SessionReviewDiffStyle
  onDiffStyleChange?: (diffStyle: SessionReviewDiffStyle) => void
-  onDiffRendered?: VoidFunction
+  onDiffRendered?: () => void
  onLineComment?: (comment: SessionReviewLineComment) => void
  onLineCommentUpdate?: (comment: SessionReviewCommentUpdate) => void
  onLineCommentDelete?: (comment: SessionReviewCommentDelete) => void
@@ -89,7 +88,6 @@ export interface SessionReviewProps {
  diffs: ReviewDiff[]
  onViewFile?: (file: string) => void
  readFile?: (path: string) => Promise<FileContent | undefined>
-  lineCommentMention?: LineCommentEditorProps["mention"]
 }

 function ReviewCommentMenu(props: {
@@ -137,14 +135,11 @@ type SessionReviewSelection = {
 export const SessionReview = (props: SessionReviewProps) => {
  let scroll: HTMLDivElement | undefined
  let focusToken = 0
-  let frame: number | undefined
  const i18n = useI18n()
  const fileComponent = useFileComponent()
  const anchors = new Map<string, HTMLElement>()
-  const nodes = new Map<string, HTMLDivElement>()
  const [store, setStore] = createStore({
    open: [] as string[],
-    visible: {} as Record<string, boolean>,
    force: {} as Record<string, boolean>,
    selection: null as SessionReviewSelection | null,
    commenting: null as SessionReviewSelection | null,
@@ -157,84 +152,13 @@ export const SessionReview = (props: SessionReviewProps) => {
  const open = () => props.open ?? store.open
  const files = createMemo(() => props.diffs.map((diff) => diff.file))
  const diffs = createMemo(() => new Map(props.diffs.map((diff) => [diff.file, diff] as const)))
-  const grouped = createMemo(() => {
-    const next = new Map<string, SessionReviewComment[]>()
-    for (const comment of props.comments ?? []) {
-      const list = next.get(comment.file)
-      if (list) {
-        list.push(comment)
-        continue
-      }
-      next.set(comment.file, [comment])
-    }
-    return next
-  })
  const diffStyle = () => props.diffStyle ?? (props.split ? "split" : "unified")
  const hasDiffs = () => files().length > 0

-  const syncVisible = () => {
-    frame = undefined
-    if (!scroll) return
-
-    const root = scroll.getBoundingClientRect()
-    const top = root.top - REVIEW_MOUNT_MARGIN
-    const bottom = root.bottom + REVIEW_MOUNT_MARGIN
-    const openSet = new Set(open())
-    const next: Record<string, boolean> = {}
-
-    for (const [file, el] of nodes) {
-      if (!openSet.has(file)) continue
-      const rect = el.getBoundingClientRect()
-      if (rect.bottom < top || rect.top > bottom) continue
-      next[file] = true
-    }
-
-    const prev = untrack(() => store.visible)
-    const prevKeys = Object.keys(prev)
-    const nextKeys = Object.keys(next)
-    if (prevKeys.length === nextKeys.length && nextKeys.every((file) => prev[file])) return
-    setStore("visible", next)
-  }
-
-  const queue = () => {
-    if (frame !== undefined) return
-    frame = requestAnimationFrame(syncVisible)
-  }
-
-  const pinned = (file: string) =>
-    props.focusedComment?.file === file ||
-    props.focusedFile === file ||
-    selection()?.file === file ||
-    commenting()?.file === file ||
-    opened()?.file === file
-
-  const handleScroll: JSX.EventHandler<HTMLDivElement, Event> = (event) => {
-    queue()
-    const next = props.onScroll
-    if (!next) return
-    if (Array.isArray(next)) {
-      const [fn, data] = next as [(data: unknown, event: Event) => void, unknown]
-      fn(data, event)
-      return
-    }
-    ;(next as JSX.EventHandler<HTMLDivElement, Event>)(event)
-  }
-
-  onCleanup(() => {
-    if (frame === undefined) return
-    cancelAnimationFrame(frame)
-  })
-
-  createEffect(() => {
-    props.open
-    files()
-    queue()
-  })
-
-  const handleChange = (next: string[]) => {
-    props.onOpenChange?.(next)
-    if (props.open === undefined) setStore("open", next)
-    queue()
+  const handleChange = (open: string[]) => {
+    props.onOpenChange?.(open)
+    if (props.open !== undefined) return
+    setStore("open", open)
  }

  const handleExpandOrCollapseAll = () => {
@@ -348,9 +272,8 @@ export const SessionReview = (props: SessionReviewProps) => {
        viewportRef={(el) => {
          scroll = el
          props.scrollRef?.(el)
-          queue()
        }}
-        onScroll={handleScroll}
+        onScroll={props.onScroll as any}
        classList={{
          [props.classes?.root ?? ""]: !!props.classes?.root,
        }}
@@ -366,10 +289,9 @@ export const SessionReview = (props: SessionReviewProps) => {
                    const item = createMemo(() => diffs().get(file)!)

                    const expanded = createMemo(() => open().includes(file))
-                    const mounted = createMemo(() => expanded() && (!!store.visible[file] || pinned(file)))
                    const force = () => !!store.force[file]

-                    const comments = createMemo(() => grouped().get(file) ?? [])
+                    const comments = createMemo(() => (props.comments ?? []).filter((c) => c.file === file))
                    const commentedLines = createMemo(() => comments().map((c) => c.selection))

                    const beforeText = () => (typeof item().before === "string" ? item().before : "")
@@ -405,7 +327,6 @@ export const SessionReview = (props: SessionReviewProps) => {
                      comments,
                      label: i18n.t("ui.lineComment.submit"),
                      draftKey: () => file,
-                      mention: props.lineCommentMention,
                      state: {
                        opened: () => {
                          const current = opened()
@@ -457,8 +378,6 @@ export const SessionReview = (props: SessionReviewProps) => {

                    onCleanup(() => {
                      anchors.delete(file)
-                      nodes.delete(file)
-                      queue()
                    })

                    const handleLineSelected = (range: SelectedLineRange | null) => {
@@ -543,19 +462,10 @@ export const SessionReview = (props: SessionReviewProps) => {
                            ref={(el) => {
                              wrapper = el
                              anchors.set(file, el)
-                              nodes.set(file, el)
-                              queue()
                            }}
                          >
                            <Show when={expanded()}>
                              <Switch>
-                                <Match when={!mounted() && !tooLarge()}>
-                                  <div
-                                    data-slot="session-review-diff-placeholder"
-                                    class="rounded-lg border border-border-weak-base bg-background-stronger/40"
-                                    style={{ height: "160px" }}
-                                  />
-                                </Match>
                                <Match when={tooLarge()}>
                                  <div data-slot="session-review-large-diff">
                                    <div data-slot="session-review-large-diff-title">
@@ -1,6 +1,6 @@
 {
  "name": "@opencode-ai/util",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "private": true,
  "type": "module",
  "license": "MIT",
@@ -2,7 +2,7 @@
  "name": "@opencode-ai/web",
  "type": "module",
  "license": "MIT",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "scripts": {
    "dev": "astro dev",
    "dev:remote": "VITE_API_URL=https://api.opencode.ai astro dev",
@@ -15,17 +15,9 @@ To create a new `AGENTS.md` file, you can run the `/init` command in opencode.
 You should commit your project's `AGENTS.md` file to Git.
 :::

-`/init` scans the important files in your repo, may ask a couple of targeted questions when the codebase cannot answer them, and then creates or updates `AGENTS.md` with concise project-specific guidance.
+This will scan your project and all its contents to understand what the project is about and generate an `AGENTS.md` file with it. This helps opencode to navigate the project better.

-It focuses on the things future agent sessions are most likely to need:
-
- build, lint, and test commands
- command order and focused verification steps when they matter
- architecture and repo structure that are not obvious from filenames alone
- project-specific conventions, setup quirks, and operational gotchas
- references to existing instruction sources like Cursor or Copilot rules
-
-If you already have an `AGENTS.md`, `/init` will improve it in place instead of blindly replacing it.
+If you have an existing `AGENTS.md` file, this will try to add to it.

 ---

@@ -153,7 +153,7 @@ Show the help dialog.

 ### init

-Guided setup for creating or updating `AGENTS.md`. [Learn more](/docs/rules).
+Create or update `AGENTS.md` file. [Learn more](/docs/rules).

 ```bash frame="none"
 /init
@@ -2,7 +2,7 @@
  "name": "opencode",
  "displayName": "opencode",
  "description": "opencode for VS Code",
-  "version": "1.3.13",
+  "version": "1.3.11",
  "publisher": "sst-dev",
  "repository": {
    "type": "git",
Author	SHA1	Message	Date
Kit Langton	8d2385ad49	test: finish HTTP mock processor coverage	2026-03-31 20:36:18 -04:00
Kit Langton	7f6a5bb2c8	test: migrate processor tests to HTTP mock LLM server Replace the custom TestLLM Effect service with the real LLM layer + TestLLMServer HTTP mock for 9 of 10 processor tests. Tests now exercise the full HTTP→SSE→AI SDK→processor pipeline. - Export Provider.defaultLayer for test layer composition - Add boot() helper for common service access (processor, session, provider) - Extend TestLLMServer with usage support and httpError step type - Tool abort test registers a real tool with hanging execute - Reasoning test stays with in-process TestLLM (needs fine-grained events)	2026-03-31 19:59:56 -04:00
Kit Langton	537cc32bf0	test: migrate processor tests to HTTP mock LLM server Replace the custom TestLLM Effect service with the real LLM layer + TestLLMServer HTTP mock. Tests now exercise the full HTTP→SSE→AI SDK pipeline instead of injecting Effect streams directly. - Extend TestLLMServer with usage support on text responses and httpError step type for non-200 responses - Drop reasoning test (can't produce reasoning events via @ai-sdk/openai-compatible SSE) - 9 tests pass, covering: text capture, token overflow, error retry, structured errors, context overflow, abort/interrupt cleanup	2026-03-31 19:21:27 -04:00
Kit Langton	82da702f64	refactor: tighten instance context helper fallbacks	2026-03-31 17:32:24 -04:00
Kit Langton	90469bbb7e	refactor: simplify instance context helpers in prompt tests	2026-03-31 16:42:20 -04:00
Kit Langton	4ff0fbc043	fix: retry scoped tempdir cleanup on windows	2026-03-31 16:42:19 -04:00
Kit Langton	e24369eaf1	fix: break installation cycle in database context binding	2026-03-31 16:42:18 -04:00
Kit Langton	825f51c39f	fix: restore instance context in deferred database callbacks	2026-03-31 16:42:18 -04:00
Kit Langton	191a747405	fix: propagate InstanceRef across static function boundaries - makeRuntime.provide reads InstanceRef from current Effect fiber when ALS is unavailable, bridging static function calls (like Bus.publish) that create new fibers from inside Effect code - Database.transaction preserves Instance ALS via Instance.bind on the bun:sqlite transaction callback (native fn loses ALS) - Instance.restore helper for bridging Effect→sync code with ALS - InstanceState.withALS bridges InstanceRef back to ALS for sync callers - prompt.ts: InstructionPrompt.clear wrapped with withALS - Remove ALL provideInstance(dir) wrappers from prompt-effect tests	2026-03-31 16:42:17 -04:00
Kit Langton	cc412f3014	refactor: migrate Instance ALS reads to InstanceRef in Effect services Migrate 16 direct Instance.directory/worktree/project reads inside Effect code to use InstanceState.directory/context helpers that check the InstanceRef first and fall back to ALS. - Export InstanceState.directory and InstanceState.context helpers - bus/index.ts: GlobalBus.emit uses InstanceState.directory - session/prompt.ts: 5 callsites migrated to InstanceState.context - session/index.ts: 4 callsites migrated - session/compaction.ts: 1 callsite migrated - config/config.ts: 1 callsite migrated - format/index.ts: 1 callsite migrated - worktree/index.ts: 5 callsites migrated - storage/db.ts: Database.effect preserves Instance ALS via Instance.bind - test/lib/llm-server.ts: add wait/hold/fail SSE stream support - Remove most provideInstance(dir) wrappers from prompt tests (5 remain due to Instance.state sync ALS dependency)	2026-03-31 16:42:16 -04:00
Kit Langton	bb039496d5	refactor: propagate Instance context through Effect fibers via InstanceRef Add a ServiceMap.Reference that carries InstanceContext through the Effect service graph so child fibers retain instance context even when resumed by external I/O events outside the ALS boundary. - Add InstanceRef to instance-state.ts; InstanceState.get/has/invalidate try the Reference first, fall back to ALS - makeRuntime automatically captures ALS into InstanceRef at the boundary - provideInstance (test fixture) sets InstanceRef for Effect.runPromiseWith - Remove all redundant provideInstance(dir) wrappers from prompt tests - Fix test/lib/effect.ts type params (drop unnecessary S/T generics)	2026-03-31 16:42:16 -04:00
Kit Langton	f2fa1a681d	test: move more prompt cases to mock llm server Migrate the next prompt-effect cases to the HTTP-backed mock server path, keep the shell handoff cases on short live timeouts, and leave the stream-failure case on the in-process fake until the server DSL matches it.	2026-03-31 16:42:15 -04:00
Kit Langton	6bd340492c	test: infer mock server callback types	2026-03-31 16:42:15 -04:00
Kit Langton	21ec3207e7	test: extend mock llm server coverage Add fixture support for tmpdir-backed mock server tests, extend the mock LLM server DSL for failure and hanging cases, and migrate the next prompt tests to the HTTP-backed path.	2026-03-31 16:42:14 -04:00
Kit Langton	123123b6c3	test: start moving prompt tests to mock llm server Switch the basic assistant reply prompt-effect test to the HTTP-backed mock LLM server while keeping the more stream-sensitive cases on the in-process fake for now.	2026-03-31 16:42:14 -04:00
Kit Langton	6ea467b0ac	test: add live effect helper mode Default the shared effect test helper to support both test-clock and live execution, and switch the current opencode effect tests to the live path for real integration behavior.	2026-03-31 16:42:13 -04:00
Kit Langton	459fbc99a8	refactor(test): migrate llm-server to Effect HTTP platform - Replace Bun.serve with Effect HTTP server using NodeHttpServer - Add TestLLMServer service for mock LLM testing with SSE responses - Update prompt-provider.test.ts to use testEffect pattern with provideTmpdirInstance - Remove redundant test/fixture/effect.ts (using existing test/lib/effect.ts instead)	2026-03-31 16:42:13 -04:00