fix(tui): clear stale tool preparation state

Prefer the terminal server projection when refresh observes a completed assistant message, so a missed tool-failure event cannot leave the TUI showing an uncancellable pending tool. Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>
fix(codemode): return final top-level expression (#35759 )
2026-07-07 20:01:37 +00:00 · 2026-07-07 11:44:50 -05:00 · 2026-07-07 12:25:29 -04:00 · 2026-07-07 12:15:01 -04:00 · 2026-07-07 12:08:45 -04:00 · 2026-07-07 11:43:40 -04:00
63 changed files with 980 additions and 1588 deletions
@@ -873,6 +873,7 @@
      "name": "@opencode-ai/simulation",
      "version": "1.17.13",
      "dependencies": {
+        "@napi-rs/canvas": "1.0.2",
        "@opencode-ai/core": "workspace:*",
        "@opencode-ai/llm": "workspace:*",
        "@opentui/core": "catalog:",
@@ -1611,11 +1612,11 @@

    "@emmetio/stream-reader-utils": ["@emmetio/stream-reader-utils@0.1.0", "", {}, "sha512-ZsZ2I9Vzso3Ho/pjZFsmmZ++FWeEd/txqybHTm4OgaZzdS8V9V/YYWQwg5TC38Z7uLWUV1vavpLLbjJtKubR1A=="],

-    "@emnapi/core": ["@emnapi/core@1.9.2", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA=="],
+    "@emnapi/core": ["@emnapi/core@1.11.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.2", "tslib": "^2.4.0" } }, "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ=="],

-    "@emnapi/runtime": ["@emnapi/runtime@1.9.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw=="],
+    "@emnapi/runtime": ["@emnapi/runtime@1.11.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw=="],

-    "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
+    "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA=="],

    "@emotion/is-prop-valid": ["@emotion/is-prop-valid@0.8.8", "", { "dependencies": { "@emotion/memoize": "0.7.4" } }, "sha512-u5WtneEAr5IDG2Wv65yhunPSMLIpuKsbuOktRojfrEiEvRyC85LgPMZI63cr7NUqT8ZIGdSVg8ZKGxIug4lXcA=="],

@@ -1983,6 +1984,30 @@

    "@msgpackr-extract/msgpackr-extract-win32-x64": ["@msgpackr-extract/msgpackr-extract-win32-x64@3.0.4", "", { "os": "win32", "cpu": "x64" }, "sha512-CmCXPQrkbwExx3j946/PtHWHbYJiCRBRDl4BlkRQcJB/YOwQxJRTpoo7aTsortjgoJ1x7opzTSxn7C+ASSLVjQ=="],

+    "@napi-rs/canvas": ["@napi-rs/canvas@1.0.2", "", { "optionalDependencies": { "@napi-rs/canvas-android-arm64": "1.0.2", "@napi-rs/canvas-darwin-arm64": "1.0.2", "@napi-rs/canvas-darwin-x64": "1.0.2", "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.2", "@napi-rs/canvas-linux-arm64-gnu": "1.0.2", "@napi-rs/canvas-linux-arm64-musl": "1.0.2", "@napi-rs/canvas-linux-riscv64-gnu": "1.0.2", "@napi-rs/canvas-linux-x64-gnu": "1.0.2", "@napi-rs/canvas-linux-x64-musl": "1.0.2", "@napi-rs/canvas-win32-arm64-msvc": "1.0.2", "@napi-rs/canvas-win32-x64-msvc": "1.0.2" } }, "sha512-EYEqlMYaCbpZDz+IgDH5xp9MTd3ui4dmGqbQYryhMLnSRxrhHKq5KQWHHKxFUcEP4Hp8/BWgvqXocX4j7iSbOQ=="],
+
+    "@napi-rs/canvas-android-arm64": ["@napi-rs/canvas-android-arm64@1.0.2", "", { "os": "android", "cpu": "arm64" }, "sha512-IMXKVQod0ol4vt3gmClUfXz4JAgHYESGPCUqmH3lQxBoL0K/2greJaQE1HVBVxWWFKfLc4OLZVdxg7kXVyXv+g=="],
+
+    "@napi-rs/canvas-darwin-arm64": ["@napi-rs/canvas-darwin-arm64@1.0.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Sc8tPi6cF+5lqOzCCKFALJHhDiRwyMzTPYm3bbhdXsOunU0lQO5f05ucyOzN2r55I23Hg5bsjH63uSCvWp3EgQ=="],
+
+    "@napi-rs/canvas-darwin-x64": ["@napi-rs/canvas-darwin-x64@1.0.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-niDXZ9LhKB1zLrUdYB64RHQFDGz9rr0eGx061qtJJU3U20EMMIx28ADF5fVYbhtOgkWQrBjFicfaye1yM0U62A=="],
+
+    "@napi-rs/canvas-linux-arm-gnueabihf": ["@napi-rs/canvas-linux-arm-gnueabihf@1.0.2", "", { "os": "linux", "cpu": "arm" }, "sha512-sgatQL9JxGRH/Amzcvu0P3t8Am3duou74CisfuJ41Dwt8cWy723z/9KZ8LlgmxfypEwEZxSTNFJtU8d281lmhQ=="],
+
+    "@napi-rs/canvas-linux-arm64-gnu": ["@napi-rs/canvas-linux-arm64-gnu@1.0.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-dgKuX0peF3xwY6ZF5QxGS4wbfDqpoFAJYXiLSp+guZKARQUKMkRqZSDrXKj7nfrec3UCMzC0PFCPte0ES98AiA=="],
+
+    "@napi-rs/canvas-linux-arm64-musl": ["@napi-rs/canvas-linux-arm64-musl@1.0.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-qwROoDIC9upfvDoRLuPn2aNg9CGW1x0Ygr4k2Or+8paA9d0qBLwk87U+g8KQpoOviKoPoiwl97kvBYuYD7qZoA=="],
+
+    "@napi-rs/canvas-linux-riscv64-gnu": ["@napi-rs/canvas-linux-riscv64-gnu@1.0.2", "", { "os": "linux", "cpu": "none" }, "sha512-fXRjnPihdnbO6qy1QQOgxAonb68A0TCEG7rj1x7v7rxNElsE8EVIKIEUTvyDtU+sthYSbX+8e7g3oZiLGnOmxw=="],
+
+    "@napi-rs/canvas-linux-x64-gnu": ["@napi-rs/canvas-linux-x64-gnu@1.0.2", "", { "os": "linux", "cpu": "x64" }, "sha512-nPR97DXhbWIAy7yazF3jc06kEPMqYMLmPzFOVNlwKPfIoSChnI+x7dc0hTLaihz3jxrjL6j4BbA7earxfx4X3g=="],
+
+    "@napi-rs/canvas-linux-x64-musl": ["@napi-rs/canvas-linux-x64-musl@1.0.2", "", { "os": "linux", "cpu": "x64" }, "sha512-l7zZY5+jL5qnBZtDz7CoBtY6p7EkHu422g/0zWwrOrzIwWyWxZFRfZZORY1UG7YApymPLx+UbOkN206xXn/c1Q=="],
+
+    "@napi-rs/canvas-win32-arm64-msvc": ["@napi-rs/canvas-win32-arm64-msvc@1.0.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-yE0koHCFF4PIbMc2o2SEALhnipz7WBISh5glLvQiomtIoCcW0np3H4Lw93ceJAfJttTTeIIWFbwH84F7EVzjMQ=="],
+
+    "@napi-rs/canvas-win32-x64-msvc": ["@napi-rs/canvas-win32-x64-msvc@1.0.2", "", { "os": "win32", "cpu": "x64" }, "sha512-okU8/t2foV6C31n0GtvEMbfD5rOFc70+/6xUNME9Guld29sgSOIGUEDScAWFlcP3k5TYQRl9TNkwJEEjh15w8A=="],
+
    "@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.4", "", { "dependencies": { "@tybys/wasm-util": "^0.10.1" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow=="],

    "@noble/hashes": ["@noble/hashes@2.2.0", "", {}, "sha512-IYqDGiTXab6FniAgnSdZwgWbomxpy9FtYvLKs7wCUs2a8RkITG+DFGO1DM9cr+E3/RgADRpFjrKVaJ1z6sjtEg=="],
@@ -2277,7 +2302,7 @@

    "@oxc-parser/binding-win32-x64-msvc": ["@oxc-parser/binding-win32-x64-msvc@0.127.0", "", { "os": "win32", "cpu": "x64" }, "sha512-rOrnSQSCbhI2kowr9XxE7m9a8oQXnBHjnS6j95LxxAnEZ0+Fz20WlRXG4ondQb+ejjt2KOsa65sE6++L6kUd+w=="],

-    "@oxc-project/types": ["@oxc-project/types@0.127.0", "", {}, "sha512-aIYXQBo4lCbO4z0R3FHeucQHpF46l2LbMdxRvqvuRuW2OxdnSkcng5B8+K12spgLDj93rtN3+J2Vac/TIO+ciQ=="],
+    "@oxc-project/types": ["@oxc-project/types@0.138.0", "", {}, "sha512-1a7ZKmrRTCoN1XMZ4L0PyyqrMnrNlLyPuOkdSX2MZg7IiIGRUyurNhAm73ptDOraoBcIordsIGKNPKUzy3ZmfA=="],

    "@oxc-resolver/binding-android-arm-eabi": ["@oxc-resolver/binding-android-arm-eabi@11.20.0", "", { "os": "android", "cpu": "arm" }, "sha512-IjfWOXRgJFNdORDl+Uf1aibNgZY2guOD3zmOhx1BGVb/MIiqlFTdmjpQNplSN58lhWehnX4UNqC3QwpUo8pjJg=="],

@@ -2569,7 +2594,37 @@

    "@remix-run/router": ["@remix-run/router@1.9.0", "", {}, "sha512-bV63itrKBC0zdT27qYm6SDZHlkXwFL1xMBuhkn+X7l0+IIhNaH5wuuvZKp6eKhCD4KFhujhfhCT1YxXW6esUIA=="],

-    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.27", "", {}, "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA=="],
+    "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.1.4", "", { "os": "android", "cpu": "arm64" }, "sha512-EZLpf/8y7GXkkra90ML47kzik/GMP3EMcE9bPyHmRfxLC6z9+aW5A8poCsoxjrT5GfEcNAAvWwUHjvP1pUQkfw=="],
+
+    "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.1.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-aUi+HBvmYb7j8krl1+qJgkG8C17fO79gk3c+jPw4S8glRFc1DTija9S3EyaTSQUm5GJXYKDAsugBEhFHH2vYiQ=="],
+
+    "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.1.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-F7hHC3gwY11+vByKPRWqwGbeXWVgKmL+pTGCinaEhdihzBV2aQ0fvZOch9cXYUOKuKKq429HeYXOqQLc7wFCEg=="],
+
+    "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.1.4", "", { "os": "freebsd", "cpu": "x64" }, "sha512-sI5yw+7s92SK6odiEhD5lKCBlWcpjHS5qyqpVQbZAJ0fIzEUXrmbl3DH2ybR3PZogulNJF+COLtmA8hUfvkCCQ=="],
+
+    "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.1.4", "", { "os": "linux", "cpu": "arm" }, "sha512-mCi0OKgEieFircrtVYmQAFGszRtMnZ6fpZAXrxanXAu7lqZcsK1E1RAaZNG0uKAnxox3B1f4EyQNnoyMfN1vAA=="],
+
+    "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.1.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-B9Ial3Kv5sh0SHnB1g/QWcUQCEvCF6QKGAl4zXypYj65mVI+B4AhFBwPtSN7pDrJeIx8Z7zdy4ntx+wQABom7w=="],
+
+    "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.1.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-lZVym0PuHE1KZ22gmFTC15lAkrg9iTszR617oYRB/iPY1A56ywoJzVKOJBKaot5RiikCObmur6pogpse3gRcng=="],
+
+    "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.1.4", "", { "os": "linux", "cpu": "ppc64" }, "sha512-t2DNiLJWNTbnEHyUzTumldML6ET4/g16467LZoDDJ3tSxGvguL5/NyC2lCsNKuyRycg9XeDQF5SSv+TNOhQEXg=="],
+
+    "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.1.4", "", { "os": "linux", "cpu": "s390x" }, "sha512-0WIRnL1Uw4BvTZRLQt+PVgo6ZKTJadlC2btP+/EOXv2f/DWbY0rEgl+y834mIVwP1FkTlWVTrGGJXf12lru7EQ=="],
+
+    "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.1.4", "", { "os": "linux", "cpu": "x64" }, "sha512-JWtGshGfX+oENAKonoNkqEJX+7hC8yfhi9GUyPX1VX4mdh1y5r+ZiJLR5XzAB0aoP6s/PcILsGjKq8O0mm24bw=="],
+
+    "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.1.4", "", { "os": "linux", "cpu": "x64" }, "sha512-rT6yQcxUuXs4CnbofqwHRRV0iem349rLMYpTjkgQGLjrY4ado/eDzwPZPTCgTOlF6Nkp8NEv70yLMTn6qkWxsQ=="],
+
+    "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.1.4", "", { "os": "none", "cpu": "arm64" }, "sha512-KXMGoboq5cyaCQjDA4GLuRiOwBQ0EyFnJoVViLeZ45/3rFItRODEr+NdsBcVpll40hhNArlm/speWGRvj08LzA=="],
+
+    "@rolldown/binding-wasm32-wasi": ["@rolldown/binding-wasm32-wasi@1.1.4", "", { "dependencies": { "@emnapi/core": "1.11.1", "@emnapi/runtime": "1.11.1", "@napi-rs/wasm-runtime": "^1.1.6" }, "cpu": "none" }, "sha512-5K83rb36oJiY7BCyE9zLZtGcPV4g5wvq+xwdO0XPIwDVZI8cyB/AUjkNXGb92/rnmezEkjMOpgY61rtwjQtFwg=="],
+
+    "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.1.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-PnWBtw3TV5KOg69HQQDR0mnQuyCmSGR2pAB4DC1rPF808fgKeTUMj2EOEyKATpgiuxuR5APQmiDO7PDgEjTFSA=="],
+
+    "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.1.4", "", { "os": "win32", "cpu": "x64" }, "sha512-M1lpniBePobTfsa7Ks9a199e1akxsXn+GYBUKsEzv3YFzOm1HJAMNwKI3qr0Zq+mxwx9gOZoTdP1yXRYsZUocQ=="],
+
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="],

    "@rollup/pluginutils": ["@rollup/pluginutils@5.4.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg=="],

@@ -3111,6 +3166,8 @@

    "@types/react": ["@types/react@18.0.25", "", { "dependencies": { "@types/prop-types": "*", "@types/scheduler": "*", "csstype": "^3.0.2" } }, "sha512-xD6c0KDT4m7n9uD4ZHi02lzskaiqcBxf4zi+tXZY98a04wvc0hi/TcCPC2FOESZi51Nd7tlUeOJY8RofL799/g=="],

+    "@types/react-dom": ["@types/react-dom@19.2.3", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ=="],
+
    "@types/responselike": ["@types/responselike@1.0.3", "", { "dependencies": { "@types/node": "*" } }, "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw=="],

    "@types/retry": ["@types/retry@0.12.0", "", {}, "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA=="],
@@ -3183,6 +3240,12 @@

    "@valibot/to-json-schema": ["@valibot/to-json-schema@1.6.0", "", { "peerDependencies": { "valibot": "^1.3.0" } }, "sha512-d6rYyK5KVa2XdqamWgZ4/Nr+cXhxjy7lmpe6Iajw15J/jmU+gyxl2IEd1Otg1d7Rl3gOQL5reulnSypzBtYy1A=="],

+    "@vercel/cli-config": ["@vercel/cli-config@0.2.0", "", { "dependencies": { "xdg-app-paths": "5", "zod": "4.1.11" } }, "sha512-fJRRRB7734BDuXZ89yBEaA2ncYhH7bWX30mk04W80J6VAfQc+4iB8lyzAdaGpFV3/vNlkt9VZt+/uoQoWX6UsQ=="],
+
+    "@vercel/cli-exec": ["@vercel/cli-exec@1.0.0", "", { "dependencies": { "execa": "5.1.1" } }, "sha512-kQF8LGie/Hbdq9/psJxLE7owRTcqMQMhgybU04gCeR7cbQAr5t8OrjefDNColJv1QSSucFt4pLwRiARVmlOnug=="],
+
+    "@vercel/functions": ["@vercel/functions@3.7.5", "", { "dependencies": { "@vercel/oidc": "3.8.0" }, "peerDependencies": { "@aws-sdk/credential-provider-web-identity": "*", "ws": ">=8" }, "optionalPeers": ["@aws-sdk/credential-provider-web-identity", "ws"] }, "sha512-ESf8BbeDebqRUyMi09JwRbQqpLn4g6fjcVVHPsHB56j2dSqRrSHO4h3X4aaxJf6iQQjzhAtDGI2xCWQ27JE8PA=="],
+
    "@vercel/oidc": ["@vercel/oidc@3.2.0", "", {}, "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug=="],

    "@vitejs/plugin-react": ["@vitejs/plugin-react@4.7.0", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-beta.27", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA=="],
@@ -4987,6 +5050,8 @@

    "opentui-spinner": ["opentui-spinner@0.0.7", "", { "dependencies": { "cli-spinners": "^3.3.0" }, "peerDependencies": { "@opentui/core": "^0.3.4", "@opentui/react": "^0.3.4", "@opentui/solid": "^0.3.4", "typescript": "^5" }, "optionalPeers": ["@opentui/react", "@opentui/solid"] }, "sha512-nPzwAvJG+y9rVEwwHLHqbsMzLnIk2zw+F9LqwA7aYJvpM5gsrKC2rrGi36A+tZpA+1RnWxXeWEgVZMchnaH18Q=="],

+    "os-paths": ["os-paths@4.4.0", "", {}, "sha512-wrAwOeXp1RRMFfQY8Sy7VaGVmPocaLwSFOYCGKSyo8qmJ+/yaafCl5BCA1IQZWqFSRBrKDYFeR9d/VyQzfH/jg=="],
+
    "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="],

    "oxc-minify": ["oxc-minify@0.96.0", "", { "optionalDependencies": { "@oxc-minify/binding-android-arm64": "0.96.0", "@oxc-minify/binding-darwin-arm64": "0.96.0", "@oxc-minify/binding-darwin-x64": "0.96.0", "@oxc-minify/binding-freebsd-x64": "0.96.0", "@oxc-minify/binding-linux-arm-gnueabihf": "0.96.0", "@oxc-minify/binding-linux-arm-musleabihf": "0.96.0", "@oxc-minify/binding-linux-arm64-gnu": "0.96.0", "@oxc-minify/binding-linux-arm64-musl": "0.96.0", "@oxc-minify/binding-linux-riscv64-gnu": "0.96.0", "@oxc-minify/binding-linux-s390x-gnu": "0.96.0", "@oxc-minify/binding-linux-x64-gnu": "0.96.0", "@oxc-minify/binding-linux-x64-musl": "0.96.0", "@oxc-minify/binding-wasm32-wasi": "0.96.0", "@oxc-minify/binding-win32-arm64-msvc": "0.96.0", "@oxc-minify/binding-win32-x64-msvc": "0.96.0" } }, "sha512-dXeeGrfPJJ4rMdw+NrqiCRtbzVX2ogq//R0Xns08zql2HjV3Zi2SBJ65saqfDaJzd2bcHqvGWH+M44EQCHPAcA=="],
@@ -5401,6 +5466,8 @@

    "roarr": ["roarr@2.15.4", "", { "dependencies": { "boolean": "^3.0.1", "detect-node": "^2.0.4", "globalthis": "^1.0.1", "json-stringify-safe": "^5.0.1", "semver-compare": "^1.0.0", "sprintf-js": "^1.1.2" } }, "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A=="],

+    "rolldown": ["rolldown@1.1.4", "", { "dependencies": { "@oxc-project/types": "=0.138.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm64": "1.1.4", "@rolldown/binding-darwin-arm64": "1.1.4", "@rolldown/binding-darwin-x64": "1.1.4", "@rolldown/binding-freebsd-x64": "1.1.4", "@rolldown/binding-linux-arm-gnueabihf": "1.1.4", "@rolldown/binding-linux-arm64-gnu": "1.1.4", "@rolldown/binding-linux-arm64-musl": "1.1.4", "@rolldown/binding-linux-ppc64-gnu": "1.1.4", "@rolldown/binding-linux-s390x-gnu": "1.1.4", "@rolldown/binding-linux-x64-gnu": "1.1.4", "@rolldown/binding-linux-x64-musl": "1.1.4", "@rolldown/binding-openharmony-arm64": "1.1.4", "@rolldown/binding-wasm32-wasi": "1.1.4", "@rolldown/binding-win32-arm64-msvc": "1.1.4", "@rolldown/binding-win32-x64-msvc": "1.1.4" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-IjZYiLxZwpnhwhdBH2ugdTGVSdhCQUmLxLoqyjiL0JxYjyRst+5a0P3xfrTxJ5F638j4Mvvw5FAX5XE6eHpXbA=="],
+
    "rollup": ["rollup@4.60.4", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.60.4", "@rollup/rollup-android-arm64": "4.60.4", "@rollup/rollup-darwin-arm64": "4.60.4", "@rollup/rollup-darwin-x64": "4.60.4", "@rollup/rollup-freebsd-arm64": "4.60.4", "@rollup/rollup-freebsd-x64": "4.60.4", "@rollup/rollup-linux-arm-gnueabihf": "4.60.4", "@rollup/rollup-linux-arm-musleabihf": "4.60.4", "@rollup/rollup-linux-arm64-gnu": "4.60.4", "@rollup/rollup-linux-arm64-musl": "4.60.4", "@rollup/rollup-linux-loong64-gnu": "4.60.4", "@rollup/rollup-linux-loong64-musl": "4.60.4", "@rollup/rollup-linux-ppc64-gnu": "4.60.4", "@rollup/rollup-linux-ppc64-musl": "4.60.4", "@rollup/rollup-linux-riscv64-gnu": "4.60.4", "@rollup/rollup-linux-riscv64-musl": "4.60.4", "@rollup/rollup-linux-s390x-gnu": "4.60.4", "@rollup/rollup-linux-x64-gnu": "4.60.4", "@rollup/rollup-linux-x64-musl": "4.60.4", "@rollup/rollup-openbsd-x64": "4.60.4", "@rollup/rollup-openharmony-arm64": "4.60.4", "@rollup/rollup-win32-arm64-msvc": "4.60.4", "@rollup/rollup-win32-ia32-msvc": "4.60.4", "@rollup/rollup-win32-x64-gnu": "4.60.4", "@rollup/rollup-win32-x64-msvc": "4.60.4", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g=="],

    "rou3": ["rou3@0.7.12", "", {}, "sha512-iFE4hLDuloSWcD7mjdCDhx2bKcIsYbtOTpfH5MHHLSKMOUyjqQXTeZVa289uuwEGEKFoE/BAPbhaU4B774nceg=="],
@@ -6021,8 +6088,12 @@

    "wsl-utils": ["wsl-utils@0.3.1", "", { "dependencies": { "is-wsl": "^3.1.0", "powershell-utils": "^0.1.0" } }, "sha512-g/eziiSUNBSsdDJtCLB8bdYEUMj4jR7AGeUo96p/3dTafgjHhpF4RiCFPiRILwjQoDXx5MqkBr4fwWtR3Ky4Wg=="],

+    "xdg-app-paths": ["xdg-app-paths@5.5.1", "", { "dependencies": { "os-paths": "^4.0.1", "xdg-portable": "^7.2.0" } }, "sha512-hI3flOB4PLZIy5prbtTpirobtPE2ZtZ52szO+2mM9Efp6ErM398La+C1lIpNWDfNoQk+6Lsi6nMcCwVB7pxeMQ=="],
+
    "xdg-basedir": ["xdg-basedir@5.1.0", "", {}, "sha512-GCPAHLvrIH13+c0SuacwvRYj2SxJXQ4kaVTT5xgL3kPrz56XxkF21IGhjSE1+W0aw7gpBWRGXLCPnPby6lSpmQ=="],

+    "xdg-portable": ["xdg-portable@7.3.0", "", { "dependencies": { "os-paths": "^4.0.1" } }, "sha512-sqMMuL1rc0FmMBOzCpd0yuy9trqF2yTTVe+E9ogwCSWQCdDEtQUwrZPT6AxqtsFGRNxycgncbP/xmOOSPw5ZUw=="],
+
    "xml-naming": ["xml-naming@0.1.0", "", {}, "sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw=="],

    "xml2js": ["xml2js@0.5.0", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA=="],
@@ -6619,6 +6690,10 @@

    "@oslojs/jwt/@oslojs/encoding": ["@oslojs/encoding@0.4.1", "", {}, "sha512-hkjo6MuIK/kQR5CrGNdAPZhS01ZCXuWDRJ187zh6qqF2+yMHZpD9fAYpX8q2bOO6Ryhl3XpCT6kUX76N8hhm4Q=="],

+    "@oxc-parser/binding-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.9.2", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA=="],
+
+    "@oxc-parser/binding-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.9.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw=="],
+
    "@oxc-resolver/binding-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.10.0", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw=="],

    "@oxc-resolver/binding-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.10.0", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA=="],
@@ -6639,6 +6714,8 @@

    "@puppeteer/browsers/yargs": ["yargs@17.7.2", "", { "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", "get-caller-file": "^2.0.5", "require-directory": "^2.1.1", "string-width": "^4.2.3", "y18n": "^5.0.5", "yargs-parser": "^21.1.1" } }, "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w=="],

+    "@rolldown/binding-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.6", "", { "dependencies": { "@tybys/wasm-util": "^0.10.3" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg=="],
+
    "@rollup/pluginutils/estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],

    "@sentry/bundler-plugin-core/glob": ["glob@9.3.5", "", { "dependencies": { "fs.realpath": "^1.0.0", "minimatch": "^8.0.2", "minipass": "^4.2.4", "path-scurry": "^1.6.1" } }, "sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q=="],
@@ -6747,6 +6824,14 @@

    "@types/plist/xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="],

+    "@vercel/cli-config/zod": ["zod@4.1.11", "", {}, "sha512-WPsqwxITS2tzx1bzhIKsEs19ABD5vmCVa4xBo2tq/SrV4RNZtfws1EnCWQXM6yh8bD08a1idvkB5MZSBiZsjwg=="],
+
+    "@vercel/cli-exec/execa": ["execa@5.1.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^6.0.0", "human-signals": "^2.1.0", "is-stream": "^2.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^4.0.1", "onetime": "^5.1.2", "signal-exit": "^3.0.3", "strip-final-newline": "^2.0.0" } }, "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg=="],
+
+    "@vercel/functions/@vercel/oidc": ["@vercel/oidc@3.8.0", "", { "dependencies": { "@vercel/cli-config": "0.2.0", "@vercel/cli-exec": "1.0.0", "jose": "^5.9.6" } }, "sha512-r00laGW6Pv778RoR6M2NxX91ycSj+PBwVo+fOb9Bif+F0IyUKt25zrvBzfEzQpeAzbqOgPZyQibEWDdDFApd+A=="],
+
+    "@vitejs/plugin-react/@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.27", "", {}, "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA=="],
+
    "@vitest/coverage-v8/@vitest/utils": ["@vitest/utils@4.1.8", "", { "dependencies": { "@vitest/pretty-format": "4.1.8", "convert-source-map": "^2.0.0", "tinyrainbow": "^3.1.0" } }, "sha512-uOJamYALNhfJ6iolExyQM40yIQwDqYnkKtQ5VCiSe17E33H0aQ/u+1GlRuz4LZBk6Mm3sg90G9hEbmEt37C1Zg=="],

    "@vitest/coverage-v8/magicast": ["magicast@0.5.3", "", { "dependencies": { "@babel/parser": "^7.29.3", "@babel/types": "^7.29.0", "source-map-js": "^1.2.1" } }, "sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw=="],
@@ -7043,6 +7128,8 @@

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

+    "oxc-parser/@oxc-project/types": ["@oxc-project/types@0.127.0", "", {}, "sha512-aIYXQBo4lCbO4z0R3FHeucQHpF46l2LbMdxRvqvuRuW2OxdnSkcng5B8+K12spgLDj93rtN3+J2Vac/TIO+ciQ=="],
+
    "p-any/p-cancelable": ["p-cancelable@3.0.0", "", {}, "sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw=="],

    "p-locate/p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
@@ -7707,6 +7794,10 @@

    "@opentui/solid/@babel/core/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],

+    "@oxc-parser/binding-wasm32-wasi/@emnapi/core/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
+
+    "@oxc-resolver/binding-wasm32-wasi/@emnapi/core/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="],
+
    "@pierre/diffs/@shikijs/transformers/@shikijs/core": ["@shikijs/core@3.20.0", "", { "dependencies": { "@shikijs/types": "3.20.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-f2ED7HYV4JEk827mtMDwe/yQ25pRiXZmtHjWF8uzZKuKiEsJR7Ce1nuQ+HhV9FzDcbIo4ObBCD9GPTzNuy9S1g=="],

    "@pierre/diffs/@shikijs/transformers/@shikijs/types": ["@shikijs/types@3.20.0", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-lhYAATn10nkZcBQ0BlzSbJA3wcmL5MXUUF8d2Zzon6saZDlToKaiRX60n2+ZaHJCmXEcZRWNzn+k9vplr8Jhsw=="],
@@ -7715,6 +7806,8 @@

    "@puppeteer/browsers/yargs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],

+    "@rolldown/binding-wasm32-wasi/@napi-rs/wasm-runtime/@tybys/wasm-util": ["@tybys/wasm-util@0.10.3", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg=="],
+
    "@sentry/bundler-plugin-core/glob/minimatch": ["minimatch@8.0.7", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-V+1uQNdzybxa14e/p00HZnQNNcTjnRJjDxg2V8wtkjFctq4M7hXFws4oekyTP0Jebeq7QYtpFyOeBAjc88zvYg=="],

    "@sentry/bundler-plugin-core/glob/minipass": ["minipass@4.2.8", "", {}, "sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ=="],
@@ -7785,6 +7878,22 @@

    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime/@tybys/wasm-util": ["@tybys/wasm-util@0.10.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg=="],

+    "@vercel/cli-exec/execa/get-stream": ["get-stream@6.0.1", "", {}, "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg=="],
+
+    "@vercel/cli-exec/execa/human-signals": ["human-signals@2.1.0", "", {}, "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw=="],
+
+    "@vercel/cli-exec/execa/is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
+
+    "@vercel/cli-exec/execa/npm-run-path": ["npm-run-path@4.0.1", "", { "dependencies": { "path-key": "^3.0.0" } }, "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw=="],
+
+    "@vercel/cli-exec/execa/onetime": ["onetime@5.1.2", "", { "dependencies": { "mimic-fn": "^2.1.0" } }, "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg=="],
+
+    "@vercel/cli-exec/execa/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
+
+    "@vercel/cli-exec/execa/strip-final-newline": ["strip-final-newline@2.0.0", "", {}, "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="],
+
+    "@vercel/functions/@vercel/oidc/jose": ["jose@5.9.6", "", {}, "sha512-AMlnetc9+CV9asI19zHmrgS/WYsWUwCn2R7RzlbJWD7F9eWYUTGyBmU9o6PxngtLGOiDGPRu+Uc4fhKzbpteZQ=="],
+
    "@vitest/coverage-v8/@vitest/utils/@vitest/pretty-format": ["@vitest/pretty-format@4.1.8", "", { "dependencies": { "tinyrainbow": "^3.1.0" } }, "sha512-9GasEBxpZ1VYIpqHf/0+YGg121uSNwCKOJqIrTwWP/TB7DmFCiaBpNl3aPZzoLWfWkuqhbH8vJIVobZkvdo2cA=="],

    "@vitest/expect/@vitest/utils/@vitest/pretty-format": ["@vitest/pretty-format@3.2.4", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA=="],
@@ -8351,6 +8460,8 @@

    "@stoplight/spectral-core/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],

+    "@vercel/cli-exec/execa/onetime/mimic-fn": ["mimic-fn@2.1.0", "", {}, "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg=="],
+
    "ai-gateway-provider/@ai-sdk/amazon-bedrock/@ai-sdk/provider-utils/@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],

    "ai-gateway-provider/@ai-sdk/anthropic/@ai-sdk/provider-utils/@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
@@ -7,7 +7,6 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { AppProcess } from "@opencode-ai/core/process"
-import { Flock } from "@opencode-ai/core/util/flock"
 import { start } from "@opencode-ai/server/process"
 import { randomBytes, randomUUID } from "node:crypto"
 import path from "node:path"
@@ -37,14 +36,6 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
  if (options.mode === "service") yield* Effect.sync(() => process.chdir(Global.Path.home))
  return yield* Effect.scoped(
    Effect.gen(function* () {
-      if (options.mode === "service") {
-        const service = yield* ServiceConfig.options()
-        yield* Flock.effect(path.basename(service.file, ".json") + "-process", {
-          dir: path.dirname(service.file),
-          staleMs: 3_000,
-          timeoutMs: 15_000,
-        })
-      }
      const environmentPassword = yield* Env.password
      // Keep the lease credential out of the environment inherited by tools.
      if (options.mode === "stdio") {
@@ -439,28 +439,8 @@ export type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query
 export type Endpoint10_0Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.list"]>>
 export type ServerMcpListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>

-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-export type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-export type Endpoint10_1Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.catalog"]>>
-export type ServerMcpResourceCatalogOperation<E = never> = (
-  input?: Endpoint10_1Input,
-) => Effect.Effect<Endpoint10_1Output, E>
-
-type Endpoint10_2Request = Parameters<RawClient["server.mcp"]["mcp.resource.read"]>[0]
-export type Endpoint10_2Input = {
-  readonly location?: Endpoint10_2Request["query"]["location"]
-  readonly server: Endpoint10_2Request["payload"]["server"]
-  readonly uri: Endpoint10_2Request["payload"]["uri"]
-}
-export type Endpoint10_2Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.read"]>>
-export type ServerMcpReadResourceOperation<E = never> = (
-  input: Endpoint10_2Input,
-) => Effect.Effect<Endpoint10_2Output, E>
-
 export interface ServerMcpApi<E = never> {
  readonly list: ServerMcpListOperation<E>
-  readonly resourceCatalog: ServerMcpResourceCatalogOperation<E>
-  readonly readResource: ServerMcpReadResourceOperation<E>
 }

 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
@@ -910,8 +890,14 @@ export interface VcsApi<E = never> {
 export type Endpoint25_0Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location"]>>
 export type DebugLocationOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>

+type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+export type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
+export type Endpoint25_1Output = EffectValue<ReturnType<RawClient["server.debug"]["debug.location.evict"]>>
+export type DebugEvictLocationOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+
 export interface DebugApi<E = never> {
  readonly location: DebugLocationOperation<E>
+  readonly evictLocation: DebugEvictLocationOperation<E>
 }

 export interface AppApi<E = never> {
@@ -529,28 +529,7 @@ type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["loc
 const Endpoint10_0 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_0Input) =>
  raw["mcp.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-const Endpoint10_1 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_1Input) =>
-  raw["mcp.resource.catalog"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint10_2Request = Parameters<RawClient["server.mcp"]["mcp.resource.read"]>[0]
-type Endpoint10_2Input = {
-  readonly location?: Endpoint10_2Request["query"]["location"]
-  readonly server: Endpoint10_2Request["payload"]["server"]
-  readonly uri: Endpoint10_2Request["payload"]["uri"]
-}
-const Endpoint10_2 = (raw: RawClient["server.mcp"]) => (input: Endpoint10_2Input) =>
-  raw["mcp.resource.read"]({
-    query: { location: input["location"] },
-    payload: { server: input["server"], uri: input["uri"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({
-  list: Endpoint10_0(raw),
-  resourceCatalog: Endpoint10_1(raw),
-  readResource: Endpoint10_2(raw),
-})
+const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(raw) })

 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
 type Endpoint11_0Input = {
@@ -1090,7 +1069,15 @@ const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint24_0(r
 const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
  raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))

-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({ location: Endpoint25_0(raw) })
+type Endpoint25_1Request = Parameters<RawClient["server.debug"]["debug.location.evict"]>[0]
+type Endpoint25_1Input = { readonly location?: Endpoint25_1Request["query"]["location"] }
+const Endpoint25_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint25_1Input) =>
+  raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
+  location: Endpoint25_0(raw),
+  evictLocation: Endpoint25_1(raw),
+})

 const adaptClient = (raw: RawClient) => ({
  health: adaptGroup0(raw["server.health"]),
@@ -15,7 +15,6 @@ export type {
  ProviderApi,
  ReferenceApi,
  SessionApi,
-  ServerMcpApi,
  SkillApi,
 } from "./api.js"
 export { Service } from "./service.js"
@@ -28,7 +27,6 @@ export { FileSystem } from "@opencode-ai/schema/filesystem"
 export { Form } from "@opencode-ai/schema/form"
 export { Integration } from "@opencode-ai/schema/integration"
 export { Location } from "@opencode-ai/schema/location"
-export { Mcp } from "@opencode-ai/schema/mcp"
 export { Model } from "@opencode-ai/schema/model"
 export { Permission } from "@opencode-ai/schema/permission"
 export { PermissionSaved } from "@opencode-ai/schema/permission-saved"
@@ -8,7 +8,6 @@ import type {
  ProviderApi as EffectProviderApi,
  ReferenceApi as EffectReferenceApi,
  SessionApi as EffectSessionApi,
-  ServerMcpApi as EffectServerMcpApi,
  SkillApi as EffectSkillApi,
 } from "../effect/api/api.js"
 import type { Effect, Stream } from "effect"
@@ -38,7 +37,6 @@ export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
 export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
 export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
 export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
-export type ServerMcpApi = PromisifyApi<EffectServerMcpApi<unknown>>
 export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>

 export interface CatalogApi {
@@ -87,10 +87,6 @@ import type {
  IntegrationAttemptCancelOutput,
  ServerMcpListInput,
  ServerMcpListOutput,
-  ServerMcpResourceCatalogInput,
-  ServerMcpResourceCatalogOutput,
-  ServerMcpReadResourceInput,
-  ServerMcpReadResourceOutput,
  CredentialUpdateInput,
  CredentialUpdateOutput,
  CredentialRemoveInput,
@@ -182,6 +178,8 @@ import type {
  VcsDiffInput,
  VcsDiffOutput,
  DebugLocationOutput,
+  DebugEvictLocationInput,
+  DebugEvictLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"

@@ -894,31 +892,6 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
-      resourceCatalog: (input?: ServerMcpResourceCatalogInput, requestOptions?: RequestOptions) =>
-        request<ServerMcpResourceCatalogOutput>(
-          {
-            method: "GET",
-            path: `/api/mcp/resource`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      readResource: (input: ServerMcpReadResourceInput, requestOptions?: RequestOptions) =>
-        request<ServerMcpReadResourceOutput>(
-          {
-            method: "POST",
-            path: `/api/mcp/resource/read`,
-            query: { location: input["location"] },
-            body: { server: input["server"], uri: input["uri"] },
-            successStatus: 200,
-            declaredStatuses: [404, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
    },
    credential: {
      update: (input: CredentialUpdateInput, requestOptions?: RequestOptions) =>
@@ -1523,6 +1496,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      evictLocation: (input?: DebugEvictLocationInput, requestOptions?: RequestOptions) =>
+        request<DebugEvictLocationOutput>(
+          {
+            method: "DELETE",
+            path: `/api/debug/location`,
+            query: { location: input?.["location"] },
+            successStatus: 204,
+            declaredStatuses: [401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
    },
  }
 }
@@ -106,14 +106,6 @@ export type ProviderNotFoundError = {
 export const isProviderNotFoundError = (value: unknown): value is ProviderNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProviderNotFoundError"

-export type McpServerNotFoundError = {
-  readonly _tag: "McpServerNotFoundError"
-  readonly server: string
-  readonly message: string
-}
-export const isMcpServerNotFoundError = (value: unknown): value is McpServerNotFoundError =>
-  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "McpServerNotFoundError"
-
 export type FormNotFoundError = { readonly _tag: "FormNotFoundError"; readonly id: string; readonly message: string }
 export const isFormNotFoundError = (value: unknown): value is FormNotFoundError =>
  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormNotFoundError"
@@ -2486,60 +2478,6 @@ export type ServerMcpListOutput = {
  }>
 }

-export type ServerMcpResourceCatalogInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type ServerMcpResourceCatalogOutput = {
-  readonly location: {
-    readonly directory: string
-    readonly workspaceID?: string
-    readonly project: { readonly id: string; readonly directory: string }
-  }
-  readonly data: {
-    readonly resources: ReadonlyArray<{
-      readonly server: string
-      readonly name: string
-      readonly uri: string
-      readonly description?: string
-      readonly mimeType?: string
-    }>
-    readonly templates: ReadonlyArray<{
-      readonly server: string
-      readonly name: string
-      readonly uriTemplate: string
-      readonly description?: string
-      readonly mimeType?: string
-    }>
-  }
-}
-
-export type ServerMcpReadResourceInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-  readonly server: { readonly server: string; readonly uri: string }["server"]
-  readonly uri: { readonly server: string; readonly uri: string }["uri"]
-}
-
-export type ServerMcpReadResourceOutput = {
-  readonly location: {
-    readonly directory: string
-    readonly workspaceID?: string
-    readonly project: { readonly id: string; readonly directory: string }
-  }
-  readonly data: {
-    readonly server: string
-    readonly uri: string
-    readonly contents: ReadonlyArray<
-      | { readonly type: "text"; readonly uri: string; readonly text: string; readonly mimeType?: string }
-      | { readonly type: "blob"; readonly uri: string; readonly blob: string; readonly mimeType?: string }
-    >
-  } | null
-}
-
 export type CredentialUpdateInput = {
  readonly credentialID: { readonly credentialID: string }["credentialID"]
  readonly location?: {
@@ -5570,14 +5508,6 @@ export type EventSubscribeOutput =
      readonly location?: { readonly directory: string; readonly workspaceID?: string }
      readonly data: { readonly server: string }
    }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "mcp.resources.changed"
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly server: string }
-    }
  | {
      readonly id: string
      readonly created: number
@@ -6200,3 +6130,11 @@ export type VcsDiffOutput = {
 }

 export type DebugLocationOutput = ReadonlyArray<{ readonly directory: string; readonly workspaceID?: string }>
+
+export type DebugEvictLocationInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type DebugEvictLocationOutput = void
@@ -10,7 +10,6 @@ export type {
  ProviderApi,
  ReferenceApi,
  SessionApi,
-  ServerMcpApi,
  SkillApi,
 } from "./api.js"
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types"
@@ -9,7 +9,6 @@ import { SessionInput as CoreSessionInput } from "@opencode-ai/core/session/inpu
 import { SessionMessage as CoreSessionMessage } from "@opencode-ai/core/session/message"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Location } from "@opencode-ai/schema/location"
-import { Mcp } from "@opencode-ai/schema/mcp"
 import { Model } from "@opencode-ai/schema/model"
 import { Project } from "@opencode-ai/schema/project"
 import { Provider } from "@opencode-ai/schema/provider"
@@ -27,7 +26,6 @@ const Client = await import("../src/effect")
 test("effect entrypoint exposes canonical Schema contracts", () => {
  expect(Client.Agent).toBe(Agent)
  expect(Client.Model).toBe(Model)
-  expect(Client.Mcp).toBe(Mcp)
  expect(Client.Session).toBe(Session)
 })

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { isMcpServerNotFoundError, isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src/promise/index"
+import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src/promise/index"

 test("exposes every standard HTTP API group", () => {
  const client = OpenCode.make({ baseUrl: "http://localhost:3000" })
@@ -48,74 +48,6 @@ test("exposes every standard HTTP API group", () => {
  expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
  expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "timeout", "output", "remove"])
  expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
-  expect(Object.keys(client["server.mcp"])).toEqual(["list", "resourceCatalog", "readResource"])
-})
-
-test("MCP resource methods use the public HTTP contract", async () => {
-  const requests: Array<{ method: string; url: string; body?: unknown }> = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push({
-        method: request.method,
-        url: request.url,
-        body: request.method === "POST" ? await request.json() : undefined,
-      })
-      if (request.method === "POST")
-        return Response.json({
-          location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-          data: {
-            server: "docs",
-            uri: "docs://readme",
-            contents: [{ type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" }],
-          },
-        })
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: {
-          resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-          templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-        },
-      })
-    },
-  })
-
-  const location = { directory: "/tmp/project" }
-  expect((await client["server.mcp"].resourceCatalog({ location })).data.resources[0]?.uri).toBe("docs://readme")
-  expect(
-    (await client["server.mcp"].readResource({ server: "docs", uri: "docs://readme", location })).data?.contents,
-  ).toEqual([{ type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" }])
-  expect(requests).toEqual([
-    {
-      method: "GET",
-      url: "http://localhost:3000/api/mcp/resource?location%5Bdirectory%5D=%2Ftmp%2Fproject",
-      body: undefined,
-    },
-    {
-      method: "POST",
-      url: "http://localhost:3000/api/mcp/resource/read?location%5Bdirectory%5D=%2Ftmp%2Fproject",
-      body: { server: "docs", uri: "docs://readme" },
-    },
-  ])
-})
-
-test("MCP resource reads preserve unknown-server errors", async () => {
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      Response.json(
-        { _tag: "McpServerNotFoundError", server: "missing", message: "MCP server not found: missing" },
-        { status: 404 },
-      ),
-  })
-
-  try {
-    await client["server.mcp"].readResource({ server: "missing", uri: "docs://readme" })
-    throw new Error("Expected request to fail")
-  } catch (error) {
-    expect(isMcpServerNotFoundError(error)).toBe(true)
-  }
 })

 test("file.read returns binary content from the public HTTP contract", async () => {
@@ -62,7 +62,7 @@ const result =

 `result` is always a `CodeMode.Result`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.

-Successful result values are JSON-safe data. A program that returns `undefined`, including by reaching the end without `return`, produces `null`; nested `undefined` values are normalized to `null` as well.
+Successful result values are JSON-safe data. An explicit `return` produces the program result; when it is omitted, the final executable top-level expression is returned as a model-friendly REPL convenience. Otherwise reaching the end produces `null`. Returned `undefined` and nested `undefined` values are normalized to `null` as well.

 ## API

@@ -30,7 +30,6 @@ export type Binding = {

 export type StatementResult =
  | { kind: "none" }
-  | { kind: "value"; value: unknown }
  | { kind: "return"; value: unknown }
  | { kind: "break" }
  | { kind: "continue" }
@@ -606,7 +606,6 @@ class Interpreter<R> {
  // ToolRuntime.make like invokeTool: the interpreter never holds the tree itself.
  private readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>
  private readonly logs: Array<string>
-  private lastValue: unknown
  // Caps how many eagerly forked tool calls run at once (the parallel-call concurrency cap).
  private readonly callPermits: Semaphore.Semaphore
  // Fiber-backed promises whose settlement no program construct has observed yet. Successful
@@ -625,7 +624,6 @@ class Interpreter<R> {
    this.invokeTool = invokeTool
    this.toolKeys = toolKeys
    this.logs = logs
-    this.lastValue = undefined
    this.callPermits = shared?.callPermits ?? Semaphore.makeUnsafe(TOOL_CALL_CONCURRENCY)
    this.pendingSettlements = shared?.pendingSettlements ?? new Set<SandboxPromise>()
    globalScope.set("tools", { mutable: false, value: new ToolReference([]) })
@@ -671,13 +669,15 @@ class Interpreter<R> {
    return Effect.gen(function* () {
      self.hoistFunctions(program.body)
      let value: unknown = undefined
-      let returned = false
-      for (const statement of program.body) {
+      for (const [index, statement] of program.body.entries()) {
+        if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
+          value = yield* self.evaluateExpression(getNode(statement, "expression"))
+          break
+        }
        const result = yield* self.evaluateStatement(statement)

        if (result.kind === "return") {
          value = result.value
-          returned = true
          break
        }

@@ -685,11 +685,7 @@ class Interpreter<R> {
          throw new InterpreterRuntimeError(`Unexpected '${result.kind}' outside of a loop.`, statement)
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
      }
-      if (!returned) value = self.lastValue

      // The program body runs inside an implicit async function, so a returned promise
      // resolves before crossing the data boundary - `return tools.ns.tool(...)` works
@@ -780,7 +776,7 @@ class Interpreter<R> {
  private evaluateStatement(node: AstNode): Effect.Effect<StatementResult, unknown, R> {
    switch (node.type) {
      case "ExpressionStatement":
-        return Effect.map(this.evaluateExpression(getNode(node, "expression")), (value) => ({ kind: "value", value }))
+        return Effect.as(this.evaluateExpression(getNode(node, "expression")), { kind: "none" })
      case "VariableDeclaration":
        return Effect.map(this.evaluateVariableDeclaration(node), () => ({ kind: "none" }))
      case "ReturnStatement": {
@@ -833,11 +829,6 @@ class Interpreter<R> {
        const statement = asNode(statementValue, "body")
        const result = yield* self.evaluateStatement(statement)

-        if (result.kind === "value") {
-          self.lastValue = result.value
-          continue
-        }
-
        if (result.kind !== "none") {
          return result
        }
@@ -929,7 +920,6 @@ class Interpreter<R> {
          const result = yield* self.evaluateStatement(asNode(statementValue, "consequent"))
          if (result.kind === "break") return { kind: "none" } satisfies StatementResult
          if (result.kind === "return" || result.kind === "continue") return result
-          if (result.kind === "value") self.lastValue = result.value
        }
      }
      return { kind: "none" } satisfies StatementResult
@@ -957,9 +947,6 @@ class Interpreter<R> {
          return result
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
      }

      return { kind: "none" } satisfies StatementResult
@@ -987,9 +974,6 @@ class Interpreter<R> {
          return result
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
      } while (yield* self.evaluateExpression(testNode))

      return { kind: "none" } satisfies StatementResult
@@ -1045,10 +1029,6 @@ class Interpreter<R> {
          return { kind: "none" } satisfies StatementResult
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
-
        if (iterationScope) {
          const loopScope = self.currentScope()
          for (const name of perIterationBindings) {
@@ -1133,10 +1113,6 @@ class Interpreter<R> {
          return { kind: "none" }
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
-
        if (result.kind === "continue") {
          continue
        }
@@ -1226,10 +1202,6 @@ class Interpreter<R> {
          return { kind: "none" }
        }

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
-
        if (result.kind === "continue") {
          continue
        }
@@ -2372,7 +2344,7 @@ class Interpreter<R> {

      if (fn.body.type === "BlockStatement") {
        const result = yield* invocation.evaluateStatement(fn.body)
-        return result.kind === "return" || result.kind === "value" ? result.value : undefined
+        return result.kind === "return" ? result.value : undefined
      }

      return yield* invocation.evaluateExpression(fn.body)
@@ -1081,6 +1081,24 @@ describe("CodeMode public contract", () => {
    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
  })

+  test("returns the final top-level expression when return is omitted", async () => {
+    const result = await Effect.runPromise(CodeMode.execute({ code: `1; 2` }))
+
+    expect(result).toStrictEqual({ ok: true, value: 2, toolCalls: [] })
+  })
+
+  test("does not implicitly return expressions nested in control flow", async () => {
+    const result = await Effect.runPromise(CodeMode.execute({ code: `if (true) { 2 }` }))
+
+    expect(result).toStrictEqual({ ok: true, value: null, toolCalls: [] })
+  })
+
+  test("returns null when the final top-level statement is not an expression", async () => {
+    const result = await Effect.runPromise(CodeMode.execute({ code: `1; const value = 2` }))
+
+    expect(result).toStrictEqual({ ok: true, value: null, toolCalls: [] })
+  })
+
  test("rejects invalid configuration and discovery limits", async () => {
    expect(() => CodeMode.execute({ code: "return 1", limits: { timeoutMs: 0 } })).toThrow(RangeError)
    expect(() => CodeMode.execute({ code: "return 1", limits: { timeoutMs: Number.POSITIVE_INFINITY } })).toThrow(
@@ -150,31 +150,44 @@ export type LocationError = LayerNode.Error<typeof locationServices>
 export function buildLocationServiceMap(
  replacements: LayerNode.Replacements = [],
 ): Layer.Layer<LocationServiceMap.Service> {
+  // Structural Equal is own-key-set sensitive, so `{ directory }` (schema-decoded
+  // payloads omit optional keys) and `{ directory, workspaceID: undefined }` are
+  // different RcMap keys. The RcMap caches by the raw key before the build
+  // callback runs, so canonicalize at the map boundary to the key-present shape.
+  const canonical = (ref: Location.Ref) => Location.Ref.make({ directory: ref.directory, workspaceID: ref.workspaceID })
  return Layer.effect(
    LocationServiceMap.Service,
-    LayerMap.make(
-      (ref: Location.Ref) => {
-        const startedAt = performance.now()
-        const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
-        // Apply replacements during hoist, not afterward: replacements can
-        // introduce new tagged dependencies (Location.boundNode depends on
-        // Project), and the hoist walk is the only pass that can still slice
-        // those back out.
-        const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements)
+    Effect.map(
+      LayerMap.make(
+        (ref: Location.Ref) => {
+          const startedAt = performance.now()
+          const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
+          // Apply replacements during hoist, not afterward: replacements can
+          // introduce new tagged dependencies (Location.boundNode depends on
+          // Project), and the hoist walk is the only pass that can still slice
+          // those back out.
+          const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements)

-        return LayerNode.compile(location.node).pipe(
-          Layer.fresh,
-          Layer.tap(() =>
-            Effect.logInfo("location services booted", {
-              directory: ref.directory,
-              workspaceID: ref.workspaceID,
-              durationMs: Math.round(performance.now() - startedAt),
-            }),
-          ),
-          Layer.provide(LayerNode.compile(location.hoisted)),
-        )
-      },
-      { idleTimeToLive: "60 minutes" },
+          return LayerNode.compile(location.node).pipe(
+            Layer.fresh,
+            Layer.tap(() =>
+              Effect.logInfo("location services booted", {
+                directory: ref.directory,
+                workspaceID: ref.workspaceID,
+                durationMs: Math.round(performance.now() - startedAt),
+              }),
+            ),
+            Layer.provide(LayerNode.compile(location.hoisted)),
+          )
+        },
+        { idleTimeToLive: "60 minutes" },
+      ),
+      (inner) => ({
+        ...inner,
+        get: (ref: Location.Ref) => inner.get(canonical(ref)),
+        contextEffect: (ref: Location.Ref) => inner.contextEffect(canonical(ref)),
+        invalidate: (ref: Location.Ref) => inner.invalidate(canonical(ref)),
+      }),
    ),
  )
 }
@@ -21,24 +21,15 @@ import {
  ListToolsResultSchema,
  PromptListChangedNotificationSchema,
  PromptSchema,
-  ResourceListChangedNotificationSchema,
-  ResourceUpdatedNotificationSchema,
  type LoggingMessageNotification,
  LoggingMessageNotificationSchema,
  ToolListChangedNotificationSchema,
  ToolSchema,
 } from "@modelcontextprotocol/sdk/types.js"
-import { Cause, Effect, Exit, Schema, Scope, Semaphore } from "effect"
+import { Cause, Effect, Exit, Schema } from "effect"
 import { ConfigMCP } from "../config/mcp"
 import { InstallationVersion } from "../installation/version"

-declare module "@modelcontextprotocol/sdk/client/streamableHttp.js" {
-  interface StreamableHTTPClientTransport {
-    /** Added by the repository's MCP SDK session-recovery patch. */
-    onsessionexpired?: () => Promise<void>
-  }
-}
-
 const DEFAULT_STARTUP_TIMEOUT = 30_000
 const DEFAULT_CATALOG_TIMEOUT = 30_000
 const DEFAULT_EXECUTION_TIMEOUT = 12 * 60 * 60 * 1_000 // 12 hours
@@ -77,13 +68,11 @@ export interface ToolDefinition {
 export interface PromptDefinition {
  readonly name: string
  readonly description: string | undefined
-  readonly arguments:
-    | ReadonlyArray<{
-        readonly name: string
-        readonly description: string | undefined
-        readonly required: boolean | undefined
-      }>
-    | undefined
+  readonly arguments: ReadonlyArray<{
+    readonly name: string
+    readonly description: string | undefined
+    readonly required: boolean | undefined
+  }> | undefined
 }

 export interface PromptMessage {
@@ -95,28 +84,6 @@ export interface PromptResult {
  readonly messages: ReadonlyArray<PromptMessage>
 }

-export interface ResourceDefinition {
-  readonly name: string
-  readonly uri: string
-  readonly description: string | undefined
-  readonly mimeType: string | undefined
-}
-
-export interface ResourceTemplateDefinition {
-  readonly name: string
-  readonly uriTemplate: string
-  readonly description: string | undefined
-  readonly mimeType: string | undefined
-}
-
-export type ResourceContentPart =
-  | { readonly type: "text"; readonly uri: string; readonly text: string; readonly mimeType: string | undefined }
-  | { readonly type: "blob"; readonly uri: string; readonly blob: string; readonly mimeType: string | undefined }
-
-export interface ReadResourceResult {
-  readonly contents: ReadonlyArray<ResourceContentPart>
-}
-
 export type CallToolContent =
  | { readonly type: "text"; readonly text: string }
  | { readonly type: "media"; readonly data: string; readonly mimeType: string }
@@ -157,17 +124,6 @@ export interface Connection {
  readonly tools: () => Effect.Effect<ToolDefinition[], Error>
  /** Lists the server's prompts; returns [] when the server doesn't advertise prompt support, fails on a transport error. */
  readonly prompts: () => Effect.Effect<PromptDefinition[], Error>
-  /** Lists the server's resources; returns [] when the server doesn't advertise resource support. */
-  readonly resources: () => Effect.Effect<ResourceDefinition[], Error>
-  /** Lists the server's resource templates; returns [] when the server doesn't advertise resource support. */
-  readonly resourceTemplates: () => Effect.Effect<ResourceTemplateDefinition[], Error>
-  /** Reads one resource; returns undefined when the server doesn't advertise resource support. */
-  readonly readResource: (input: { readonly uri: string }) => Effect.Effect<ReadResourceResult | undefined, Error>
-  /** Subscribes for the lifetime of the current scope; duplicate local listeners share one server subscription. */
-  readonly subscribeResource: (
-    input: { readonly uri: string },
-    callback: () => void,
-  ) => Effect.Effect<boolean, Error, Scope.Scope>
  /** Invokes a prompt on the server. Interruption aborts the in-flight request. */
  readonly prompt: (input: {
    readonly name: string
@@ -185,8 +141,6 @@ export interface Connection {
  readonly onToolsChanged: (callback: () => void) => void
  /** Registers a callback fired when the server announces its prompt list changed; no-op if unsupported. */
  readonly onPromptsChanged: (callback: () => void) => void
-  /** Registers a callback fired when the server announces its resource catalog changed or its HTTP session recovers. */
-  readonly onResourcesChanged: (callback: () => void) => void
 }

 /** Connects an MCP server; closing the calling scope tears down the transport and any spawned process. */
@@ -214,8 +168,7 @@ export const connect = Effect.fnUntraced(function* (
        },
      })
    }
-    if (!URL.canParse(config.url))
-      return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` })
+    if (!URL.canParse(config.url)) return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` })
    return new StreamableHTTPClientTransport(new URL(config.url), {
      requestInit: config.headers ? { headers: config.headers } : undefined,
      authProvider,
@@ -249,57 +202,13 @@ export const connect = Effect.fnUntraced(function* (
  }).pipe(Effect.exit)
  if (Exit.isSuccess(exit)) {
    yield* Effect.addFinalizer(() =>
-      cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => client.close())), Effect.ignore),
+      cleanupStdioDescendants(transport).pipe(
+        Effect.andThen(Effect.promise(() => client.close())),
+        Effect.ignore,
+      ),
    )
    const catalogTimeout = config.timeout?.catalog ?? DEFAULT_CATALOG_TIMEOUT
    const executionTimeout = config.timeout?.execution ?? DEFAULT_EXECUTION_TIMEOUT
-    const resourceSubscriptions = new Map<string, Set<() => void>>()
-    const resourceListChangedCallbacks = new Set<() => void>()
-    const resourceSubscriptionLock = Semaphore.makeUnsafe(1)
-    const notify = async (callbacks: Iterable<() => void>) => {
-      for (const callback of callbacks) {
-        try {
-          await callback()
-        } catch {}
-      }
-    }
-    client.setNotificationHandler(ResourceUpdatedNotificationSchema, (notification) =>
-      notify(resourceSubscriptions.get(notification.params.uri) ?? []),
-    )
-    client.setNotificationHandler(ResourceListChangedNotificationSchema, () => notify(resourceListChangedCallbacks))
-    if (transport instanceof StreamableHTTPClientTransport) {
-      const recover = transport.onsessionexpired
-      transport.onsessionexpired = async () => {
-        await recover?.()
-        await notify(resourceListChangedCallbacks)
-        if (client.getServerCapabilities()?.resources?.subscribe)
-          // The transport cannot send ordinary requests until its recovery callback returns.
-          setTimeout(() => {
-            Effect.runFork(
-              resourceSubscriptionLock.withPermit(
-                Effect.forEach(
-                  resourceSubscriptions.keys(),
-                  (uri) =>
-                    Effect.tryPromise({
-                      try: (signal) => client.subscribeResource({ uri }, { signal, timeout: catalogTimeout }),
-                      catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-                    }).pipe(
-                      Effect.tapError((error) =>
-                        Effect.logWarning("failed to restore MCP resource subscription", {
-                          server,
-                          uri,
-                          error: error.message,
-                        }),
-                      ),
-                      Effect.ignore,
-                    ),
-                  { discard: true },
-                ),
-              ),
-            )
-          }, 0)
-      }
-    }
    return {
      instructions: client.getInstructions()?.trim() || undefined,
      tools: () =>
@@ -348,9 +257,7 @@ export const connect = Effect.fnUntraced(function* (
              ),
            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP prompts", { server, error: error.message }),
-            ),
+            Effect.tapError((error) => Effect.logWarning("failed to list MCP prompts", { server, error: error.message })),
          )
          return prompts.map((prompt) => ({
            name: prompt.name,
@@ -362,127 +269,6 @@ export const connect = Effect.fnUntraced(function* (
            })),
          }))
        }),
-      resources: () =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return []
-          const resources = yield* Effect.tryPromise({
-            try: () =>
-              paginate(
-                (cursor) =>
-                  client.listResources(cursor === undefined ? undefined : { cursor }, { timeout: catalogTimeout }),
-                (result) => result.resources,
-              ),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP resources", { server, error: error.message }),
-            ),
-          )
-          return resources.map((resource) => ({
-            name: resource.name,
-            uri: resource.uri,
-            description: resource.description,
-            mimeType: resource.mimeType,
-          }))
-        }),
-      resourceTemplates: () =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return []
-          const templates = yield* Effect.tryPromise({
-            try: () =>
-              paginate(
-                (cursor) =>
-                  client.listResourceTemplates(cursor === undefined ? undefined : { cursor }, {
-                    timeout: catalogTimeout,
-                  }),
-                (result) => result.resourceTemplates,
-              ),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP resource templates", { server, error: error.message }),
-            ),
-          )
-          return templates.map((template) => ({
-            name: template.name,
-            uriTemplate: template.uriTemplate,
-            description: template.description,
-            mimeType: template.mimeType,
-          }))
-        }),
-      readResource: (input) =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return undefined
-          const result = yield* Effect.tryPromise({
-            try: (signal) => client.readResource({ uri: input.uri }, { signal, timeout: executionTimeout }),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to read MCP resource", { server, uri: input.uri, error: error.message }),
-            ),
-          )
-          return {
-            contents: result.contents.map(
-              (part): ResourceContentPart =>
-                "text" in part
-                  ? { type: "text", uri: part.uri, text: part.text, mimeType: part.mimeType }
-                  : { type: "blob", uri: part.uri, blob: part.blob, mimeType: part.mimeType },
-            ),
-          }
-        }),
-      subscribeResource: (input, callback) =>
-        Effect.acquireRelease(
-          resourceSubscriptionLock.withPermit(
-            Effect.gen(function* () {
-              if (!client.getServerCapabilities()?.resources?.subscribe) return undefined
-              const listener = () => callback()
-              const current = resourceSubscriptions.get(input.uri)
-              if (current) current.add(listener)
-              if (!current) {
-                yield* Effect.tryPromise({
-                  try: (signal) => client.subscribeResource({ uri: input.uri }, { signal, timeout: catalogTimeout }),
-                  catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-                }).pipe(
-                  Effect.tapError((error) =>
-                    Effect.logWarning("failed to subscribe to MCP resource", {
-                      server,
-                      uri: input.uri,
-                      error: error.message,
-                    }),
-                  ),
-                )
-                resourceSubscriptions.set(input.uri, new Set([listener]))
-              }
-              return listener
-            }),
-          ),
-          (listener) => {
-            if (!listener) return Effect.void
-            return resourceSubscriptionLock.withPermit(
-              Effect.gen(function* () {
-                const listeners = resourceSubscriptions.get(input.uri)
-                if (!listeners) return
-                listeners.delete(listener)
-                if (listeners.size > 0) return
-                resourceSubscriptions.delete(input.uri)
-                yield* Effect.tryPromise({
-                  try: (signal) => client.unsubscribeResource({ uri: input.uri }, { signal, timeout: catalogTimeout }),
-                  catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-                }).pipe(
-                  Effect.tapError((error) =>
-                    Effect.logWarning("failed to unsubscribe from MCP resource", {
-                      server,
-                      uri: input.uri,
-                      error: error.message,
-                    }),
-                  ),
-                  Effect.ignore,
-                )
-              }),
-            )
-          },
-          { interruptible: true },
-        ).pipe(Effect.map((listener) => listener !== undefined)),
      prompt: (input) =>
        Effect.tryPromise({
          try: (signal) =>
@@ -529,10 +315,7 @@ export const connect = Effect.fnUntraced(function* (
          })),
        ),
      onClose: (callback) => {
-        client.onclose = () => {
-          resourceSubscriptions.clear()
-          callback()
-        }
+        client.onclose = callback
      },
      onLog: (callback) => {
        client.setNotificationHandler(LoggingMessageNotificationSchema, (notification) => callback(notification.params))
@@ -545,13 +328,13 @@ export const connect = Effect.fnUntraced(function* (
        if (!client.getServerCapabilities()?.prompts?.listChanged) return
        client.setNotificationHandler(PromptListChangedNotificationSchema, async () => callback())
      },
-      onResourcesChanged: (callback) => {
-        resourceListChangedCallbacks.add(callback)
-      },
    } satisfies Connection
  }

-  yield* cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => transport.close())), Effect.ignore)
+  yield* cleanupStdioDescendants(transport).pipe(
+    Effect.andThen(Effect.promise(() => transport.close())),
+    Effect.ignore,
+  )
  const error = Cause.squash(exit.cause)
  if (error instanceof UnauthorizedError) return yield* new NeedsAuthError({ server })
  return yield* new ConnectError({ server, message: error instanceof Error ? error.message : String(error) })
@@ -83,16 +83,48 @@ export class PromptResult extends Schema.Class<PromptResult>("MCP.PromptResult")
  messages: Schema.Array(PromptMessage),
 }) {}

-export const Resource = Mcp.Resource
-export type Resource = Mcp.Resource
-export const ResourceTemplate = Mcp.ResourceTemplate
-export type ResourceTemplate = Mcp.ResourceTemplate
-export const ResourceCatalog = Mcp.ResourceCatalog
-export type ResourceCatalog = Mcp.ResourceCatalog
-export const ResourceContentPart = Mcp.ResourceContentPart
-export type ResourceContentPart = Mcp.ResourceContentPart
-export const ResourceContent = Mcp.ResourceContent
-export type ResourceContent = Mcp.ResourceContent
+export class Resource extends Schema.Class<Resource>("MCP.Resource")({
+  server: ServerName,
+  name: Schema.String,
+  uri: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  mimeType: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class ResourceTemplate extends Schema.Class<ResourceTemplate>("MCP.ResourceTemplate")({
+  server: ServerName,
+  name: Schema.String,
+  uriTemplate: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  mimeType: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class ResourceCatalog extends Schema.Class<ResourceCatalog>("MCP.ResourceCatalog")({
+  resources: Schema.Array(Resource),
+  templates: Schema.Array(ResourceTemplate),
+}) {}
+
+export const ResourceContentPart = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("text"),
+    uri: Schema.String,
+    text: Schema.String,
+    mimeType: Schema.String.pipe(Schema.optional),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("blob"),
+    uri: Schema.String,
+    blob: Schema.String,
+    mimeType: Schema.String.pipe(Schema.optional),
+  }),
+]).pipe(Schema.toTaggedUnion("type"))
+export type ResourceContentPart = typeof ResourceContentPart.Type
+
+export class ResourceContent extends Schema.Class<ResourceContent>("MCP.ResourceContent")({
+  server: ServerName,
+  uri: Schema.String,
+  contents: Schema.Array(ResourceContentPart),
+}) {}

 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("MCP.NotFoundError", {
  server: ServerName,
@@ -116,9 +148,6 @@ type ServerEntry = {
  client?: MCPClient.Connection
  tools?: ReadonlyArray<Tool>
  prompts?: ReadonlyArray<Prompt>
-  resources?: ReadonlyArray<Resource>
-  resourceTemplates?: ReadonlyArray<ResourceTemplate>
-  resourceRevision: number
  // Set when a remote server is registered as an OAuth integration; the credential lives in the global store.
  integrationID?: Integration.ID
 }
@@ -179,7 +208,6 @@ export const layer = Layer.effect(
          config: { ...server, timeout: { ...timeout, ...server.timeout } },
          status: { status: "pending" },
          startup: Deferred.makeUnsafe<void>(),
-          resourceRevision: 0,
        })
      }
    }
@@ -387,55 +415,6 @@ export const layer = Layer.effect(
        ),
      })

-    const toResource = (server: ServerName, def: MCPClient.ResourceDefinition) =>
-      Resource.make({
-        server,
-        name: def.name,
-        uri: def.uri,
-        description: def.description,
-        mimeType: def.mimeType,
-      })
-
-    const toResourceTemplate = (server: ServerName, def: MCPClient.ResourceTemplateDefinition) =>
-      ResourceTemplate.make({
-        server,
-        name: def.name,
-        uriTemplate: def.uriTemplate,
-        description: def.description,
-        mimeType: def.mimeType,
-      })
-
-    const invalidateResources = (entry: ServerEntry) => {
-      entry.resourceRevision += 1
-      entry.resources = undefined
-      entry.resourceTemplates = undefined
-    }
-
-    const loadResources = Effect.fnUntraced(function* (
-      name: ServerName,
-      entry: ServerEntry,
-      connection: MCPClient.Connection,
-    ) {
-      const revision = entry.resourceRevision
-      const result = yield* Effect.all(
-        {
-          resources:
-            entry.resources === undefined
-              ? connection.resources().pipe(Effect.catch(() => Effect.succeed(undefined)))
-              : Effect.succeed(undefined),
-          templates:
-            entry.resourceTemplates === undefined
-              ? connection.resourceTemplates().pipe(Effect.catch(() => Effect.succeed(undefined)))
-              : Effect.succeed(undefined),
-        },
-        { concurrency: "unbounded" },
-      )
-      if (entry.client !== connection || entry.resourceRevision !== revision) return
-      if (result.resources !== undefined) entry.resources = result.resources.map((def) => toResource(name, def))
-      if (result.templates !== undefined)
-        entry.resourceTemplates = result.templates.map((def) => toResourceTemplate(name, def))
-    })
-
    const refreshTools = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
      connection.tools().pipe(
        Effect.map((defs) => {
@@ -462,10 +441,8 @@ export const layer = Layer.effect(
        entry.client = undefined
        entry.tools = undefined
        entry.prompts = undefined
-        invalidateResources(entry)
        entry.status = { status: "failed", error: "Connection closed" }
        fork(events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore))
-        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
        fork(events.publish(Command.Event.Updated, {}).pipe(Effect.ignore))
        fork(events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore))
      })
@@ -481,11 +458,6 @@ export const layer = Layer.effect(
      connection.onPromptsChanged(() => {
        fork(refreshPrompts(name, entry, connection).pipe(Effect.ignore))
      })
-      connection.onResourcesChanged(() => {
-        if (entry.client !== connection) return
-        invalidateResources(entry)
-        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
-      })
    }

    const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
@@ -519,7 +491,6 @@ export const layer = Layer.effect(
          Effect.exit,
        )
        if (Exit.isSuccess(result)) {
-          invalidateResources(entry)
          entry.client = result.value.connection
          entry.tools = result.value.tools.map((def) => toTool(name, def))
          entry.prompts = []
@@ -530,7 +501,6 @@ export const layer = Layer.effect(
          // after the initial registration sweep and emits no list-changed notification would otherwise
          // stay invisible to the model.
          yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-          yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
          fork(refreshPrompts(name, entry, result.value.connection).pipe(Effect.ignore))
          return
@@ -571,7 +541,6 @@ export const layer = Layer.effect(
          entry.client = undefined
          entry.tools = undefined
          entry.prompts = undefined
-          invalidateResources(entry)
          yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
        }
        yield* startServer(name, entry)
@@ -588,6 +557,11 @@ export const layer = Layer.effect(
      concurrency: "unbounded",
      discard: true,
    })
+    const gate = Effect.fnUntraced(function* (server: ServerName | string) {
+      const target = yield* requireServer(server)
+      yield* Deferred.await(target.entry.startup)
+    })
+
    return Service.of({
      servers: Effect.fn("MCP.servers")(function* () {
        const entries = Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b))
@@ -663,40 +637,11 @@ export const layer = Layer.effect(
      }),
      resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
        yield* whenAllReady
-        yield* Effect.forEach(
-          runtime,
-          ([name, entry]) => (entry.client ? loadResources(name, entry, entry.client) : Effect.void),
-          { concurrency: "unbounded", discard: true },
-        )
-        return ResourceCatalog.make({
-          resources: Array.from(runtime.values())
-            .flatMap((entry) => entry.resources ?? [])
-            .toSorted(
-              (a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name) || a.uri.localeCompare(b.uri),
-            ),
-          templates: Array.from(runtime.values())
-            .flatMap((entry) => entry.resourceTemplates ?? [])
-            .toSorted(
-              (a, b) =>
-                a.server.localeCompare(b.server) ||
-                a.name.localeCompare(b.name) ||
-                a.uriTemplate.localeCompare(b.uriTemplate),
-            ),
-        })
+        return new ResourceCatalog({ resources: [], templates: [] })
      }),
      readResource: Effect.fn("MCP.readResource")(function* (input) {
-        const target = yield* requireServer(input.server)
-        yield* Deferred.await(target.entry.startup)
-        if (!target.entry.client) return undefined
-        const result = yield* target.entry.client
-          .readResource({ uri: input.uri })
-          .pipe(Effect.catch(() => Effect.succeed(undefined)))
-        if (!result) return undefined
-        return ResourceContent.make({
-          server: target.name,
-          uri: input.uri,
-          contents: result.contents,
-        })
+        yield* gate(input.server)
+        return undefined
      }),
    })
  }),
@@ -7,14 +7,6 @@ import { EventV2 } from "../event"

 export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {} })

-export interface Store {
-  readonly plugins: Map<string, Plugin>
-}
-
-export const makeStore = (): Store => ({ plugins: new Map() })
-
-const defaultStore = makeStore()
-
 /**
 * Holds the plugins an embedder (the `@opencode-ai/sdk-next` host) contributes,
 * so `PluginSupervisor` can add them on every Location boot through the ordinary
@@ -22,10 +14,9 @@ const defaultStore = makeStore()
 * config. Registration publishes an unlocated update so every booted Location
 * reloads its plugin generation from the shared store.
 *
- * The store is shared explicitly between the SDK construction graph and the
- * embedded route graph because `LocationServiceMap` builds Location layers lazily
- * in a nested graph. Each embedded SDK creates its own store, so instances do not
- * see each other's contributions.
+ * Each host-global layer owns one private store. Location graphs reuse that
+ * layer through Effect's memoization, so separate hosts remain isolated while
+ * every Location in one host sees the same registrations.
 */
 export interface Interface {
  readonly register: (plugin: Plugin) => Effect.Effect<void>
@@ -34,26 +25,19 @@ export interface Interface {

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

-export const layerWithStore = (store: Store) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const events = yield* EventV2.Service
-      yield* Effect.addFinalizer(() =>
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const events = yield* EventV2.Service
+    const plugins = new Map<string, Plugin>()
+    return Service.of({
+      register: (plugin) =>
        Effect.sync(() => {
-          store.plugins.clear()
-        }),
-      )
-      return Service.of({
-        register: (plugin) =>
-          Effect.sync(() => {
-            store.plugins.set(plugin.id, plugin)
-          }).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
-        all: () => [...store.plugins.values()],
-      })
-    }),
-  )
-
-export const layer = layerWithStore(defaultStore)
+          plugins.set(plugin.id, plugin)
+        }).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
+      all: () => [...plugins.values()],
+    })
+  }),
+)

 export const node = makeGlobalNode({ service: Service, layer, deps: [EventV2.node] })
@@ -25,20 +25,27 @@ const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <te
 - [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]

 ## Work State
- Completed: [finished work, verified facts, or changes made; otherwise "(none)"]
- Active: [current work, partial changes, or investigation state; otherwise "(none)"]
- Blocked: [blockers, failing commands, or unknowns; otherwise "(none)"]
+### Completed
+- [finished work, verified facts, or changes made; otherwise "(none)"]
+
+### Active
+- [current work, partial changes, or investigation state; otherwise "(none)"]
+
+### Blocked
+- [blockers, failing commands, or unknowns; otherwise "(none)"]

 ## Next Move
 1. [immediate concrete action, or "(none)"]
 2. [next action if known, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
 </template>

 Rules:
 - Keep every section, even when empty.
 - Use terse bullets, not prose paragraphs.
 - Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
- Put relevant files and symbols inside the section where they matter; do not add extra sections.
 - Do not mention the summary process or that context was compacted.`

 type Settings = {
@@ -120,12 +120,12 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref) => {
  const content = message.content.flatMap((item): ContentPart[] => {
    if (item.type === "text") return [{ type: "text", text: item.text }]
    if (item.type === "reasoning")
-      return sameModel
+      return reuseProviderMetadata
        ? [
            {
              type: "reasoning",
              text: item.text,
-              providerMetadata: reuseProviderMetadata ? providerMetadata(model.providerID, item.state) : undefined,
+              providerMetadata: providerMetadata(model.providerID, item.state),
            },
          ]
        : item.text.length > 0
@@ -4,27 +4,16 @@ import {
  CallToolRequestSchema,
  GetPromptRequestSchema,
  ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js"

-const server = new Server(
-  { name: "timeout", version: "1.0.0" },
-  { capabilities: { prompts: {}, resources: {}, tools: {} } },
-)
+const server = new Server({ name: "timeout", version: "1.0.0" }, { capabilities: { prompts: {}, tools: {} } })

 server.setRequestHandler(ListToolsRequestSchema, async () => {
  if (process.env.MCP_TIMEOUT_TARGET === "catalog") await Bun.sleep(100)
  return { tools: [{ name: "slow", inputSchema: { type: "object" } }] }
 })
 server.setRequestHandler(ListPromptsRequestSchema, () => Promise.resolve({ prompts: [{ name: "slow" }] }))
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  if (process.env.MCP_TIMEOUT_TARGET === "resource-catalog") await Bun.sleep(100)
-  return { resources: [{ name: "slow", uri: "test://slow" }] }
-})
-server.setRequestHandler(ListResourceTemplatesRequestSchema, () => Promise.resolve({ resourceTemplates: [] }))
 server.setRequestHandler(CallToolRequestSchema, async () => {
  await Bun.sleep(100)
  return { content: [] }
@@ -33,9 +22,5 @@ server.setRequestHandler(GetPromptRequestSchema, async () => {
  await Bun.sleep(100)
  return { messages: [] }
 })
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  await Bun.sleep(100)
-  return { contents: [{ uri: request.params.uri, text: "slow" }] }
-})

 await server.connect(new StdioServerTransport())
@@ -14,12 +14,15 @@ export const emptyMcpLayer = Layer.succeed(
    instructions: () => Effect.succeed([]),
    prompts: () => Effect.succeed([]),
    prompt: () => Effect.succeed(undefined),
-    resourceCatalog: () => Effect.succeed(MCP.ResourceCatalog.make({ resources: [], templates: [] })),
+    resourceCatalog: () => Effect.succeed(new MCP.ResourceCatalog({ resources: [], templates: [] })),
    readResource: () => Effect.succeed(undefined),
  }),
 )

-export const emptyConfigLayer = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))
+export const emptyConfigLayer = Layer.succeed(
+  Config.Service,
+  Config.Service.of({ entries: () => Effect.succeed([]) }),
+)

 export const testLocationLayer = Layer.succeed(
  Location.Service,
@@ -3,7 +3,7 @@ import path from "path"
 import { describe, expect } from "bun:test"
 import { Config } from "@opencode-ai/schema/config"
 import { Plugin } from "@opencode-ai/schema/plugin"
-import { Context, DateTime, Effect, Equal, Hash, Schema, Stream } from "effect"
+import { Context, DateTime, Effect, Equal, Hash, RcMap, Schema, Stream } from "effect"
 import { define } from "@opencode-ai/plugin/v2/effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
@@ -12,6 +12,7 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { LocationServiceMap } from "@opencode-ai/core/location-services"
 import { Location } from "@opencode-ai/core/location"
 import { PluginV2 } from "@opencode-ai/core/plugin"
+import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProjectV2 } from "@opencode-ai/core/project"
@@ -28,8 +29,43 @@ import { Reference } from "../src/reference"
 import { ToolRegistry } from "../src/tool/registry"

 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, LocationServiceMap.node])))
+const itWithSdk = testEffect(
+  AppNodeBuilder.build(LayerNode.group([Database.node, EventV2.node, SdkPlugins.node, LocationServiceMap.node])),
+)

 describe("LocationServiceMap", () => {
+  itWithSdk.live("preserves embedded SDK plugins after Location eviction", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.gen(function* () {
+          const sdk = yield* SdkPlugins.Service
+          const locations = yield* LocationServiceMap.Service
+          const id = AgentV2.ID.make("persistent-sdk-agent")
+          const plugin = define({
+            id: "persistent-sdk-plugin",
+            effect: (ctx) => ctx.agent.transform((agents) => agents.update(id, () => {})),
+          })
+          yield* sdk.register(plugin)
+
+          const ref = Location.Ref.make({ directory: AbsolutePath.make(dir.path) })
+          const read = Effect.gen(function* () {
+            const supervisor = yield* PluginSupervisor.Service
+            yield* supervisor.ready
+            const agents = yield* AgentV2.Service
+            return yield* agents.get(id)
+          })
+
+          expect(yield* read.pipe(Effect.scoped, Effect.provide(locations.get(ref)))).toBeDefined()
+          yield* locations.invalidate(ref)
+          expect(yield* read.pipe(Effect.scoped, Effect.provide(locations.get(ref)))).toBeDefined()
+        }),
+      ),
+    ),
+  )
+
  it.live("applies ordered plugin config operations during boot", () =>
    Effect.acquireRelease(
      Effect.promise(() => tmpdir()),
@@ -172,6 +208,36 @@ describe("LocationServiceMap", () => {
    ),
  )

+  it.live("normalizes ref key shapes to one cached location graph", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((dir) =>
+        Effect.scoped(
+          Effect.gen(function* () {
+            const locations = yield* LocationServiceMap.Service
+            const directory = AbsolutePath.make(dir.path)
+            const absent = Location.Ref.make({ directory })
+            const present = Location.Ref.make({ directory, workspaceID: undefined })
+            // The two shapes are not structurally Equal: own-key sets differ.
+            expect(Object.keys(absent)).toEqual(["directory"])
+            expect(Object.keys(present)).toEqual(["directory", "workspaceID"])
+            expect(Equal.equals(absent, present)).toBe(false)
+
+            const first = yield* locations.contextEffect(absent)
+            expect(yield* locations.contextEffect(present)).toBe(first)
+            expect(Array.from(yield* RcMap.keys(locations.rcMap))).toHaveLength(1)
+
+            // Invalidating with the shape opposite to the one that booted must evict.
+            yield* locations.invalidate(present)
+            expect(Array.from(yield* RcMap.keys(locations.rcMap))).toHaveLength(0)
+          }),
+        ),
+      ),
+    ),
+  )
+
  it.live("isolates catalog state by location", () =>
    Effect.acquireRelease(
      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
@@ -3,203 +3,26 @@ import { describe, expect, test } from "bun:test"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js"
-import {
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
-  SubscribeRequestSchema,
-  UnsubscribeRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js"
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
 import { ConfigMCP } from "@opencode-ai/core/config/mcp"
-import { Config } from "@opencode-ai/core/config"
-import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
-import { Form } from "@opencode-ai/core/form"
-import { Integration } from "@opencode-ai/core/integration"
-import { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { MCPClient } from "@opencode-ai/core/mcp/client"
 import { PermissionV2 } from "@opencode-ai/core/permission"
-import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { McpTool } from "@opencode-ai/core/tool/mcp"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { Deferred, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
+import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
 import { testEffect } from "./lib/effect"
-import { location } from "./fixture/location"
 import { settleTool, toolDefinitions, toolIdentity, waitForTool } from "./lib/tool"

 let assertion: Deferred.Deferred<PermissionV2.AssertInput> | undefined
 let decision: Effect.Effect<void, PermissionV2.Error> = Effect.void
 let calls = 0

-type ResourcePage = {
-  items: Array<{ name: string; uri: string; description?: string; mimeType?: string }>
-  nextCursor?: string
-}
-
-type ResourceTemplatePage = {
-  items: Array<{ name: string; uriTemplate: string; description?: string; mimeType?: string }>
-  nextCursor?: string
-}
-
-function resourceServer(input: { resources?: boolean; subscribe?: boolean; listChanged?: boolean } = {}) {
-  return Effect.acquireRelease(
-    Effect.promise(async () => {
-      const state = {
-        resources: [] as ResourcePage["items"],
-        templates: [] as ResourceTemplatePage["items"],
-        resourcePages: undefined as Record<string, ResourcePage> | undefined,
-        templatePages: undefined as Record<string, ResourceTemplatePage> | undefined,
-        contents: [
-          { uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-          { uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-        ] as Array<{ uri: string; text: string; mimeType?: string } | { uri: string; blob: string; mimeType?: string }>,
-        resourceLists: 0,
-        templateLists: 0,
-        resourceListFailures: 0,
-        subscriptions: [] as string[],
-        unsubscriptions: [] as string[],
-        onSubscription: undefined as (() => void) | undefined,
-      }
-      const makeProtocol = async () => {
-        const protocol = new Server(
-          { name: "mcp-resources", version: "1.0.0" },
-          {
-            capabilities: {
-              tools: {},
-              ...(input.resources === false
-                ? {}
-                : { resources: { subscribe: input.subscribe, listChanged: input.listChanged } }),
-            },
-          },
-        )
-        protocol.setRequestHandler(ListToolsRequestSchema, () => Promise.resolve({ tools: [] }))
-        if (input.resources !== false) {
-          protocol.setRequestHandler(ListResourcesRequestSchema, (request) => {
-            state.resourceLists += 1
-            if (state.resourceListFailures > 0) {
-              state.resourceListFailures -= 1
-              throw new Error("resource list failed")
-            }
-            const page = state.resourcePages?.[request.params?.cursor ?? "initial"]
-            return Promise.resolve({ resources: page?.items ?? state.resources, nextCursor: page?.nextCursor })
-          })
-          protocol.setRequestHandler(ListResourceTemplatesRequestSchema, (request) => {
-            state.templateLists += 1
-            const page = state.templatePages?.[request.params?.cursor ?? "initial"]
-            return Promise.resolve({ resourceTemplates: page?.items ?? state.templates, nextCursor: page?.nextCursor })
-          })
-          protocol.setRequestHandler(ReadResourceRequestSchema, () => Promise.resolve({ contents: state.contents }))
-          protocol.setRequestHandler(SubscribeRequestSchema, (request) => {
-            state.subscriptions.push(request.params.uri)
-            state.onSubscription?.()
-            return Promise.resolve({})
-          })
-          protocol.setRequestHandler(UnsubscribeRequestSchema, (request) => {
-            state.unsubscriptions.push(request.params.uri)
-            return Promise.resolve({})
-          })
-        }
-        const transport = new WebStandardStreamableHTTPServerTransport({
-          sessionIdGenerator: () => crypto.randomUUID(),
-          enableJsonResponse: true,
-        })
-        await protocol.connect(transport)
-        return { protocol, transport }
-      }
-      let current = await makeProtocol()
-      let expireSession = false
-      const http = Bun.serve({
-        port: 0,
-        fetch: (request) => {
-          if (expireSession && request.headers.has("mcp-session-id")) {
-            expireSession = false
-            return new Response("session expired", { status: 404 })
-          }
-          return current.transport.handleRequest(request)
-        },
-      })
-      return {
-        state,
-        url: http.url.toString(),
-        sendResourceListChanged: () => current.protocol.sendResourceListChanged(),
-        sendResourceUpdated: (uri: string) => current.protocol.sendResourceUpdated({ uri }),
-        restart: async () => {
-          current = await makeProtocol()
-          expireSession = true
-        },
-        close: async () => {
-          await current.protocol.close().catch(() => {})
-          http.stop(true)
-        },
-      }
-    }),
-    (server) => Effect.promise(server.close),
-  )
-}
-
-function resourceMcpLayer(url: string, changed: Deferred.Deferred<void>) {
-  const directory = AbsolutePath.make(import.meta.dir)
-  const unusedIntegration = () => Effect.die("unused integration service")
-  let resourceChanges = 0
-  return MCP.layer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        Layer.succeed(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  info: new Config.Info({
-                    mcp: new ConfigMCP.Info({
-                      servers: { resources: new ConfigMCP.Remote({ type: "remote", url, oauth: false }) },
-                    }),
-                  }),
-                }),
-              ]),
-          }),
-        ),
-        Layer.succeed(Location.Service, Location.Service.of(location({ directory }))),
-        Layer.mock(EventV2.Service, {
-          subscribe: () => Stream.never,
-          publish: (definition) =>
-            Effect.sync(() => {
-              if (definition.type === "mcp.resources.changed" && ++resourceChanges === 2)
-                Deferred.doneUnsafe(changed, Exit.void)
-              return undefined as never
-            }),
-        }),
-        Layer.mock(Form.Service, {}),
-        Layer.mock(Integration.Service, {
-          connection: {
-            active: unusedIntegration,
-            resolve: unusedIntegration,
-            key: unusedIntegration,
-            oauth: unusedIntegration,
-            update: unusedIntegration,
-            remove: unusedIntegration,
-          },
-          attempt: {
-            status: unusedIntegration,
-            complete: unusedIntegration,
-            cancel: unusedIntegration,
-          },
-        }),
-        Layer.mock(Credential.Service, {}),
-      ),
-    ),
-  )
-}
-
 const mcp = Layer.mock(MCP.Service, {
  tools: () =>
    Effect.succeed([
@@ -418,297 +241,6 @@ test("applies the configured MCP execution timeout to prompts", async () => {
  await expect(result).rejects.toThrow("Request timed out")
 })

-test("applies configured MCP timeouts to resource operations", async () => {
-  const catalog = Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
-          "resource-catalog-timeout",
-          new ConfigMCP.Local({
-            type: "local",
-            command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-timeout.ts")],
-            environment: { MCP_TIMEOUT_TARGET: "resource-catalog" },
-            timeout: new ConfigMCP.Timeout({ catalog: 10 }),
-          }),
-          import.meta.dir,
-        )
-        return yield* connection.resources()
-      }),
-    ),
-  )
-  await expect(catalog).rejects.toThrow("Request timed out")
-
-  const read = Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
-          "resource-read-timeout",
-          new ConfigMCP.Local({
-            type: "local",
-            command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-timeout.ts")],
-            timeout: new ConfigMCP.Timeout({ execution: 10 }),
-          }),
-          import.meta.dir,
-        )
-        return yield* connection.readResource({ uri: "test://slow" })
-      }),
-    ),
-  )
-  await expect(read).rejects.toThrow("Request timed out")
-})
-
-test("lists, reads, and invalidates MCP resources", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ listChanged: true })
-        server.state.resourcePages = {
-          initial: {
-            items: [{ name: "Readme", uri: "docs://readme", description: "Project docs" }],
-            nextCursor: "resources-2",
-          },
-          "resources-2": { items: [{ name: "Logo", uri: "docs://logo", mimeType: "image/png" }] },
-        }
-        server.state.templatePages = {
-          initial: {
-            items: [{ name: "File", uriTemplate: "docs://{path}" }],
-            nextCursor: "templates-2",
-          },
-          "templates-2": { items: [{ name: "Issue", uriTemplate: "issue://{id}", description: "Issue" }] },
-        }
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-
-        expect(yield* connection.resources()).toEqual([
-          { name: "Readme", uri: "docs://readme", description: "Project docs", mimeType: undefined },
-          { name: "Logo", uri: "docs://logo", description: undefined, mimeType: "image/png" },
-        ])
-        expect(yield* connection.resourceTemplates()).toEqual([
-          { name: "File", uriTemplate: "docs://{path}", description: undefined, mimeType: undefined },
-          { name: "Issue", uriTemplate: "issue://{id}", description: "Issue", mimeType: undefined },
-        ])
-        expect(yield* connection.readResource({ uri: "docs://readme" })).toEqual({
-          contents: [
-            { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-            { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-          ],
-        })
-
-        const changed = yield* Deferred.make<void>()
-        connection.onResourcesChanged(() => Deferred.doneUnsafe(changed, Exit.void))
-        yield* Effect.promise(server.sendResourceListChanged)
-        yield* Deferred.await(changed)
-      }),
-    ),
-  )
-})
-
-test("shares scoped MCP resource subscriptions", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ subscribe: true })
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        const firstScope = yield* Scope.make()
-        const secondScope = yield* Scope.make()
-        const secondUpdate = yield* Deferred.make<void>()
-
-        expect(
-          yield* connection
-            .subscribeResource({ uri: "docs://readme" }, () => {
-              throw new Error("listener failed")
-            })
-            .pipe(Scope.provide(firstScope)),
-        ).toBe(true)
-        expect(
-          yield* connection
-            .subscribeResource({ uri: "docs://readme" }, () => Deferred.doneUnsafe(secondUpdate, Exit.void))
-            .pipe(Scope.provide(secondScope)),
-        ).toBe(true)
-        expect(server.state.subscriptions).toEqual(["docs://readme"])
-
-        yield* Effect.promise(() => server.sendResourceUpdated("docs://readme"))
-        yield* Deferred.await(secondUpdate)
-        yield* Scope.close(firstScope, Exit.void)
-        expect(server.state.unsubscriptions).toEqual([])
-        yield* Scope.close(secondScope, Exit.void)
-        expect(server.state.unsubscriptions).toEqual(["docs://readme"])
-      }),
-    ),
-  )
-})
-
-test("releases MCP resource subscriptions provided a closed scope", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ subscribe: true })
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        const closed = yield* Scope.make()
-        yield* Scope.close(closed, Exit.void)
-        expect(
-          yield* connection
-            .subscribeResource({ uri: "docs://readme" }, () => {})
-            .pipe(
-              Scope.provide(closed),
-              Effect.timeoutOrElse({
-                duration: "1 second",
-                orElse: () => Effect.fail(new Error("closed-scope resource subscription deadlocked")),
-              }),
-            ),
-        ).toBe(true)
-        expect(server.state.subscriptions).toEqual(["docs://readme"])
-        expect(server.state.unsubscriptions).toEqual(["docs://readme"])
-      }),
-    ),
-  )
-})
-
-test("restores MCP resource state after HTTP session recovery", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ subscribe: true, listChanged: true })
-        server.state.resources = [{ name: "Readme", uri: "docs://readme" }]
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        const changed = yield* Deferred.make<void>()
-        const subscriptionScope = yield* Scope.make()
-        connection.onResourcesChanged(() => Deferred.doneUnsafe(changed, Exit.void))
-        expect(
-          yield* connection
-            .subscribeResource({ uri: "docs://readme" }, () => {})
-            .pipe(Scope.provide(subscriptionScope)),
-        ).toBe(true)
-
-        yield* Effect.promise(server.restart)
-        server.state.resources = [{ name: "Guide", uri: "docs://guide" }]
-        const resubscribed = yield* Deferred.make<void>()
-        server.state.onSubscription = () => Deferred.doneUnsafe(resubscribed, Exit.void)
-        expect((yield* connection.resources()).map((resource) => resource.uri)).toEqual(["docs://guide"])
-        yield* Deferred.await(changed)
-        yield* Deferred.await(resubscribed)
-        expect(server.state.subscriptions).toEqual(["docs://readme", "docs://readme"])
-        yield* Scope.close(subscriptionScope, Exit.void)
-      }),
-    ),
-  )
-})
-
-test("skips unsupported MCP resource subscriptions", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer()
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        expect(yield* connection.subscribeResource({ uri: "docs://readme" }, () => {})).toBe(false)
-        expect(server.state.subscriptions).toEqual([])
-      }),
-    ),
-  )
-})
-
-test("skips MCP resource requests when the capability is absent", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ resources: false })
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        expect(yield* connection.resources()).toEqual([])
-        expect(yield* connection.resourceTemplates()).toEqual([])
-        expect(yield* connection.readResource({ uri: "docs://readme" })).toBeUndefined()
-        expect({ resources: server.state.resourceLists, templates: server.state.templateLists }).toEqual({
-          resources: 0,
-          templates: 0,
-        })
-      }),
-    ),
-  )
-})
-
-test("caches and invalidates MCP resource catalogs", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ listChanged: true, subscribe: true })
-        server.state.resources = [{ name: "Readme", uri: "docs://readme" }]
-        server.state.templates = [{ name: "File", uriTemplate: "docs://{path}" }]
-        server.state.resourceListFailures = 1
-        const changed = yield* Deferred.make<void>()
-
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-          expect(yield* service.resourceCatalog()).toEqual({
-            resources: [],
-            templates: [
-              {
-                server: "resources",
-                name: "File",
-                uriTemplate: "docs://{path}",
-                description: undefined,
-                mimeType: undefined,
-              },
-            ],
-          })
-          expect((yield* service.resourceCatalog()).resources).toEqual([
-            {
-              server: "resources",
-              name: "Readme",
-              uri: "docs://readme",
-              description: undefined,
-              mimeType: undefined,
-            },
-          ])
-          yield* service.resourceCatalog()
-          expect({ resources: server.state.resourceLists, templates: server.state.templateLists }).toEqual({
-            resources: 2,
-            templates: 1,
-          })
-
-          server.state.resources = [{ name: "Guide", uri: "docs://guide" }]
-          yield* Effect.promise(server.sendResourceListChanged)
-          yield* Deferred.await(changed)
-          expect((yield* service.resourceCatalog()).resources.map((resource) => resource.uri)).toEqual(["docs://guide"])
-          expect({ resources: server.state.resourceLists, templates: server.state.templateLists }).toEqual({
-            resources: 3,
-            templates: 2,
-          })
-          expect(yield* service.readResource({ server: "resources", uri: "docs://readme" })).toEqual({
-            server: "resources",
-            uri: "docs://readme",
-            contents: [
-              { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-              { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-            ],
-          })
-        }).pipe(Effect.provide(resourceMcpLayer(server.url, changed)))
-      }),
-    ),
-  )
-})
-
 it.effect("advertises MCP output schemas to Code Mode", () =>
  Effect.gen(function* () {
    const registry = yield* ToolRegistry.Service
@@ -52,6 +52,15 @@ const it = testEffect(
  ),
 )

+test("compaction prompt preserves detailed work state and relevant files", () => {
+  const prompt = SessionCompaction.buildPrompt({ context: ["conversation history"] })
+
+  expect(prompt).toContain("## Work State\n### Completed")
+  expect(prompt).toContain("### Active")
+  expect(prompt).toContain("### Blocked")
+  expect(prompt).toContain("## Relevant Files")
+})
+
 test("compaction describes tool media without embedding base64", () => {
  const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
  const serialized = SessionCompaction.serializeToolContent([
@@ -74,13 +83,14 @@ test("compaction prompt requires the checkpoint headings in order", () => {
    "## Objective",
    "## Important Details",
    "## Work State",
+    "### Completed",
+    "### Active",
+    "### Blocked",
    "## Next Move",
+    "## Relevant Files",
  ])
  expect(prompt).toContain("one or two brief sentences")
  expect(prompt).toContain("constraints/preferences, decisions and why")
-  expect(prompt).toContain("Completed:")
-  expect(prompt).toContain("Active:")
-  expect(prompt).toContain("Blocked:")
  expect(prompt).toContain("immediate concrete action")
  expect(prompt).toContain("next action if known")
  expect(prompt).toContain("Keep every section, even when empty.")
@@ -461,7 +461,7 @@ Recent work
    ])
  })

-  test("drops provider-native continuation metadata from failed assistant turns", () => {
+  test("lowers failed assistant reasoning to text", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
@@ -501,7 +501,7 @@ Recent work
    )

    expect(messages[0]?.content).toEqual([
-      { type: "reasoning", text: "Partial thought", providerMetadata: undefined },
+      { type: "text", text: "Partial thought" },
      {
        type: "tool-call",
        id: "hosted-failed",
@@ -17,7 +17,12 @@
    "tabs": [
      {
        "tab": "Docs",
-        "pages": ["index", "config", "plugins", "troubleshooting"]
+        "groups": [
+          {
+            "group": "Get started",
+            "pages": ["index", "config", "plugins", "troubleshooting"]
+          }
+        ]
      },
      {
        "tab": "SDK",
@@ -39,19 +44,6 @@
    ],
    "global": {}
  },
-  "navbar": {
-    "links": [
-      {
-        "label": "Discord",
-        "href": "https://opencode.ai/discord"
-      }
-    ],
-    "primary": {
-      "type": "button",
-      "label": "GitHub",
-      "href": "https://github.com/anomalyco/opencode"
-    }
-  },
  "contextual": {
    "options": ["copy", "view", "chatgpt", "claude", "mcp", "cursor", "vscode"]
  },
@@ -6,6 +6,7 @@ const patterns = [
  /input is too long for requested model/i,
  /exceeds the context window/i,
  /input token count.*exceeds the maximum/i,
+  /tokens in request more than max tokens allowed/i,
  /maximum prompt length is \d+/i,
  /reduce the length of the messages/i,
  /maximum context length is \d+ tokens/i,
@@ -0,0 +1,8 @@
+import { describe, expect, test } from "bun:test"
+import { isContextOverflow } from "../src"
+
+describe("provider error classification", () => {
+  test("classifies Z.AI GLM token limit messages as context overflow", () => {
+    expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
+  })
+})
@@ -1448,6 +1448,7 @@ describe("session.message-v2.fromError", () => {
      "prompt is too long: 213462 tokens > 200000 maximum",
      "Your input exceeds the context window of this model",
      "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)",
+      "tokens in request more than max tokens allowed",
      "Please reduce the length of the messages or completion",
      "400 status code (no body)",
      "413 status code (no body)",
@@ -61,8 +61,7 @@ export const groupNames = {
 } as const

 export const endpointNames = {
-  "mcp.resource.catalog": "resourceCatalog",
-  "mcp.resource.read": "readResource",
+  "debug.location.evict": "evictLocation",
  "session.messages": "list",
  "integration.connect.key": "connectKey",
  "integration.connect.oauth": "connectOauth",
@@ -61,15 +61,6 @@ export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFo
  { httpApiStatus: 404 },
 ) {}

-export class McpServerNotFoundError extends Schema.TaggedErrorClass<McpServerNotFoundError>()(
-  "McpServerNotFoundError",
-  {
-    server: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
 export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
  "SessionNotFoundError",
  {
@@ -1,6 +1,7 @@
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"

 export const DebugGroup = HttpApiGroup.make("server.debug")
  .add(
@@ -14,4 +15,18 @@ export const DebugGroup = HttpApiGroup.make("server.debug")
      }),
    ),
  )
+  .add(
+    HttpApiEndpoint.delete("debug.location.evict", "/api/debug/location", {
+      query: LocationQuery,
+      success: HttpApiSchema.NoContent,
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.debug.location.evict",
+          summary: "Evict a loaded location",
+          description: "Dispose the requested location's cached services so its next use boots them fresh.",
+        }),
+      ),
+  )
  .annotateMerge(OpenApi.annotations({ title: "debug" }))
@@ -2,7 +2,6 @@ import { Mcp } from "@opencode-ai/schema/mcp"
 import { Location } from "@opencode-ai/schema/location"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { McpServerNotFoundError } from "../errors.js"
 import { LocationQuery, locationQueryOpenApi } from "./location.js"

 export const McpGroup = HttpApiGroup.make("server.mcp")
@@ -20,34 +19,4 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
        }),
      ),
  )
-  .add(
-    HttpApiEndpoint.get("mcp.resource.catalog", "/api/mcp/resource", {
-      query: LocationQuery,
-      success: Location.response(Mcp.ResourceCatalog),
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.mcp.resource.catalog",
-          summary: "List MCP resources",
-          description: "Retrieve resources and resource templates from connected MCP servers.",
-        }),
-      ),
-  )
-  .add(
-    HttpApiEndpoint.post("mcp.resource.read", "/api/mcp/resource/read", {
-      query: LocationQuery,
-      payload: Schema.Struct({ server: Schema.String, uri: Schema.String }),
-      success: Location.response(Schema.NullOr(Mcp.ResourceContent)),
-      error: McpServerNotFoundError,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.mcp.resource.read",
-          summary: "Read MCP resource",
-          description: "Read the current content of one resource from a connected MCP server.",
-        }),
-      ),
-  )
-  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server and resource routes." }))
+  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server status routes." }))
@@ -4,6 +4,5 @@ import { isOpenCodeEvent } from "../src/groups/event.js"
 test("classifies public events by type", () => {
  expect(isOpenCodeEvent({ type: "server.connected" })).toBe(true)
  expect(isOpenCodeEvent({ type: "mcp.status.changed" })).toBe(true)
-  expect(isOpenCodeEvent({ type: "mcp.resources.changed" })).toBe(true)
  expect(isOpenCodeEvent({ type: "mcp.tools.changed" })).toBe(false)
 })
@@ -80,7 +80,6 @@ export const ServerDefinitions = Event.inventory(
  ...InstallationEvent.Definitions,
  ...VcsEvent.Definitions,
  McpEvent.StatusChanged,
-  McpEvent.ResourcesChanged,
  // Shared transitional: V1 contracts the current TUI still consumes during
  // the migration (permission.asked/replied, question.asked, session.error).
  // Remove when the TUI moves to the current permission/question surfaces.
@@ -9,7 +9,6 @@ export { Form } from "./form.js"
 export { Integration } from "./integration.js"
 export { LLM } from "./llm.js"
 export { Location } from "./location.js"
-export { Mcp } from "./mcp.js"
 export { Model } from "./model.js"
 export { Permission } from "./permission.js"
 export { PermissionSaved } from "./permission-saved.js"
@@ -10,13 +10,6 @@ export const ToolsChanged = Event.ephemeral({
  },
 })

-export const ResourcesChanged = Event.ephemeral({
-  type: "mcp.resources.changed",
-  schema: {
-    server: Schema.String,
-  },
-})
-
 export const BrowserOpenFailed = Event.ephemeral({
  type: "mcp.browser.open.failed",
  schema: {
@@ -34,4 +27,4 @@ export const StatusChanged = Event.ephemeral({
  },
 })

-export const Definitions = Event.inventory(ToolsChanged, ResourcesChanged, StatusChanged)
+export const Definitions = Event.inventory(ToolsChanged, StatusChanged)
@@ -25,9 +25,14 @@ const NeedsClientRegistration = Schema.Struct({
 }).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" })

 export type Status = typeof Status.Type
-export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth, NeedsClientRegistration]).pipe(
-  Schema.toTaggedUnion("status"),
-)
+export const Status = Schema.Union([
+  Connected,
+  Pending,
+  Disabled,
+  Failed,
+  NeedsAuth,
+  NeedsClientRegistration,
+]).pipe(Schema.toTaggedUnion("status"))

 export interface Server extends Schema.Schema.Type<typeof Server> {}
 export const Server = Schema.Struct({
@@ -37,50 +42,3 @@ export const Server = Schema.Struct({
  // without matching by name, which could collide with provider or plugin integrations.
  integrationID: optional(IntegrationID),
 }).annotate({ identifier: "Mcp.Server" })
-
-export interface Resource extends Schema.Schema.Type<typeof Resource> {}
-export const Resource = Schema.Struct({
-  server: Schema.String,
-  name: Schema.String,
-  uri: Schema.String,
-  description: optional(Schema.String),
-  mimeType: optional(Schema.String),
-}).annotate({ identifier: "Mcp.Resource" })
-
-export interface ResourceTemplate extends Schema.Schema.Type<typeof ResourceTemplate> {}
-export const ResourceTemplate = Schema.Struct({
-  server: Schema.String,
-  name: Schema.String,
-  uriTemplate: Schema.String,
-  description: optional(Schema.String),
-  mimeType: optional(Schema.String),
-}).annotate({ identifier: "Mcp.ResourceTemplate" })
-
-export interface ResourceCatalog extends Schema.Schema.Type<typeof ResourceCatalog> {}
-export const ResourceCatalog = Schema.Struct({
-  resources: Schema.Array(Resource),
-  templates: Schema.Array(ResourceTemplate),
-}).annotate({ identifier: "Mcp.ResourceCatalog" })
-
-export const ResourceContentPart = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("text"),
-    uri: Schema.String,
-    text: Schema.String,
-    mimeType: optional(Schema.String),
-  }),
-  Schema.Struct({
-    type: Schema.Literal("blob"),
-    uri: Schema.String,
-    blob: Schema.String,
-    mimeType: optional(Schema.String),
-  }),
-]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Mcp.ResourceContentPart" }))
-export type ResourceContentPart = typeof ResourceContentPart.Type
-
-export interface ResourceContent extends Schema.Schema.Type<typeof ResourceContent> {}
-export const ResourceContent = Schema.Struct({
-  server: Schema.String,
-  uri: Schema.String,
-  contents: Schema.Array(ResourceContentPart),
-}).annotate({ identifier: "Mcp.ResourceContent" })
@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { DateTime, Schema } from "effect"
 import { Agent } from "../src/agent.js"
 import { FileSystem } from "../src/filesystem.js"
-import { Mcp } from "../src/mcp.js"
 import { Model } from "../src/model.js"
 import { Project } from "../src/project.js"
 import { Provider } from "../src/provider.js"
@@ -52,11 +51,6 @@ describe("contract hygiene", () => {
    const identifiers = [
      Agent.Color,
      FileSystem.Submatch,
-      Mcp.Resource,
-      Mcp.ResourceTemplate,
-      Mcp.ResourceCatalog,
-      Mcp.ResourceContentPart,
-      Mcp.ResourceContent,
      Model.Ref,
      Model.Capabilities,
      Model.Cost,
@@ -53,7 +53,6 @@ describe("public event manifest", () => {
    expect(EventManifest.Server.get("mcp.status.changed")).toBe(McpEvent.StatusChanged)
    expect(EventManifest.Server.get("session.deleted")).toBe(SessionEvent.Deleted)
    expect(EventManifest.Server.has("mcp.tools.changed")).toBe(false)
-    expect(EventManifest.Server.get("mcp.resources.changed")).toBe(McpEvent.ResourcesChanged)
    expect(Agent.Event.Updated.durable).toBeUndefined()
    expect(EventManifest.Durable.has("agent.updated")).toBe(false)
  })
@@ -77,7 +76,7 @@ describe("public event manifest", () => {
    expect(Form.Event.Definitions).toEqual([Form.Event.Created, Form.Event.Replied, Form.Event.Cancelled])
    expect(Reference.Event.Definitions).toEqual([Reference.Event.Updated])
    expect(Plugin.Event.Definitions).toEqual([Plugin.Event.Added, Plugin.Event.Updated])
-    expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.ResourcesChanged, McpEvent.StatusChanged])
+    expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.StatusChanged])
    expect(EventManifest.Latest.has("mcp.browser.open.failed")).toBe(false)
    expect(EventManifest.Latest.has("ide.installed")).toBe(false)
    expect(IdeEvent.Definitions).toEqual([IdeEvent.Installed])
@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Mcp } from "../src/mcp.js"
-
-describe("Mcp resources", () => {
-  test("decodes resource catalogs and omits absent metadata", () => {
-    const value = Schema.decodeUnknownSync(Mcp.ResourceCatalog)({
-      resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-      templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-    })
-
-    expect(Schema.encodeSync(Mcp.ResourceCatalog)(value)).toEqual({
-      resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-      templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-    })
-  })
-
-  test("preserves text and base64 blob contents", () => {
-    expect(
-      Schema.decodeUnknownSync(Mcp.ResourceContent)({
-        server: "docs",
-        uri: "docs://readme",
-        contents: [
-          { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-          { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-        ],
-      }),
-    ).toEqual({
-      server: "docs",
-      uri: "docs://readme",
-      contents: [
-        { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-        { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-      ],
-    })
-  })
-})
@@ -9,7 +9,6 @@ export { Credential } from "@opencode-ai/schema/credential"
 export { FileSystem } from "@opencode-ai/schema/filesystem"
 export { Integration } from "@opencode-ai/schema/integration"
 export { Location } from "@opencode-ai/schema/location"
-export { Mcp } from "@opencode-ai/schema/mcp"
 export { Model } from "@opencode-ai/schema/model"
 export { Permission } from "@opencode-ai/schema/permission"
 export { PermissionSaved } from "@opencode-ai/schema/permission-saved"
@@ -1,47 +1,23 @@
 import { OpenCode } from "@opencode-ai/client/effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { EventV2 } from "@opencode-ai/core/event"
-import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
-import { Project } from "@opencode-ai/core/project"
 import { createEmbeddedRoutes } from "@opencode-ai/server/routes"
-import { Context, Effect, Layer, Scope } from "effect"
-import { FetchHttpClient, HttpRouter, HttpServer } from "effect/unstable/http"
+import { Context, Effect, Layer, ManagedRuntime } from "effect"
+import { FetchHttpClient, HttpEffect, HttpRouter, HttpServer } from "effect/unstable/http"

 export const create = Effect.fn("OpenCode.create")(function* () {
-  const scope = yield* Scope.Scope
-  const memoMap = yield* Layer.makeMemoMap
-  const sdkPlugins = SdkPlugins.makeStore()
-  const context = yield* Layer.buildWithMemoMap(
-    AppNodeBuilder.build(LayerNode.group([EventV2.node, PermissionSaved.node, Project.node, SdkPlugins.node]), [
-      [SdkPlugins.node, SdkPlugins.layerWithStore(sdkPlugins)],
-    ]),
-    memoMap,
-    scope,
+  const runtime = yield* Effect.acquireRelease(
+    Effect.sync(() => ManagedRuntime.make(createEmbeddedRoutes().pipe(Layer.provide(HttpServer.layerServices)))),
+    (runtime) => runtime.disposeEffect,
  )
+  const context = yield* runtime.contextEffect
  const plugins = Context.get(context, SdkPlugins.Service)
-  const permissions = Context.get(context, PermissionSaved.Service)
-  const project = Context.get(context, Project.Service)
-  const web = yield* Effect.acquireRelease(
-    Effect.sync(() =>
-      HttpRouter.toWebHandler(
-        createEmbeddedRoutes(sdkPlugins).pipe(
-          HttpRouter.provideRequest(Layer.succeed(PermissionSaved.Service, permissions)),
-          HttpRouter.provideRequest(Layer.succeed(Project.Service, project)),
-          Layer.provide(HttpServer.layerServices),
-        ),
-        { disableLogger: true, memoMap },
-      ),
-    ),
-    (web) => Effect.promise(web.dispose),
-  )
-  const fetch = Object.assign((input: RequestInfo | URL, init?: RequestInit) => web.handler(new Request(input, init)), {
+  const router = Context.get(context, HttpRouter.HttpRouter)
+  const handler = HttpEffect.toWebHandler(router.asHttpEffect())
+  const fetch = Object.assign((input: RequestInfo | URL, init?: RequestInit) => handler(new Request(input, init)), {
    preconnect: () => undefined,
  }) satisfies typeof globalThis.fetch
  const client = yield* OpenCode.make({ baseUrl: "http://opencode.local" }).pipe(
-    Effect.provide(FetchHttpClient.layer),
-    Effect.provideService(FetchHttpClient.Fetch, fetch),
+    Effect.provide(FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, fetch)), Layer.fresh)),
  )
  return {
    ...client,
@@ -1,7 +1,6 @@
 import { expect, test } from "bun:test"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Model } from "@opencode-ai/schema/model"
-import { Mcp } from "@opencode-ai/schema/mcp"
 import { Session } from "@opencode-ai/schema/session"

 const SDK = await import("../src/index")
@@ -9,7 +8,6 @@ const SDK = await import("../src/index")
 test("re-exports canonical contracts directly from Schema", () => {
  expect(SDK.Agent).toBe(Agent)
  expect(SDK.Model).toBe(Model)
-  expect(SDK.Mcp).toBe(Mcp)
  expect(SDK.Session).toBe(Session)
  expect(Object.keys(SDK).sort()).toEqual([
    "AbsolutePath",
@@ -20,7 +18,6 @@ test("re-exports canonical contracts directly from Schema", () => {
    "FileSystem",
    "Integration",
    "Location",
-    "Mcp",
    "Model",
    "OpenCode",
    "Permission",
@@ -105,6 +105,50 @@ it.live(
  25_000,
 )

+it.live(
+  "preserves SDK plugins across Location eviction",
+  () =>
+    withEmbedded("opencode-embedded-plugin-eviction-", (fixture) =>
+      Effect.gen(function* () {
+        const opencode = yield* fixture.sdk.OpenCode.create()
+        const ref = location(fixture)
+        const connected = yield* Latch.make(false)
+        const booted = yield* Deferred.make<void>()
+        // The rebooted Location commits its second plugin generation.
+        const recommitted = yield* Deferred.make<void>()
+        const generations = yield* Ref.make(0)
+        const id = `evicted-sdk-${crypto.randomUUID()}`
+
+        yield* opencode.events.subscribe().pipe(
+          Stream.runForEach((event) => {
+            if (event.type === "server.connected") return connected.open
+            if (event.type !== "plugin.updated" || event.location?.directory !== fixture.directory) return Effect.void
+            return Ref.updateAndGet(generations, (total) => total + 1).pipe(
+              Effect.flatMap((total) => {
+                if (total === 1) return Deferred.succeed(booted, undefined)
+                if (total === 2) return Deferred.succeed(recommitted, undefined)
+                return Effect.void
+              }),
+              Effect.asVoid,
+            )
+          }),
+          Effect.forkScoped,
+        )
+        yield* connected.await
+        yield* opencode.plugin({ id, effect: () => Effect.void })
+
+        yield* opencode.plugin.list({ location: ref })
+        yield* Deferred.await(booted).pipe(Effect.timeout("5 seconds"))
+        yield* opencode.debug.evictLocation({ location: ref })
+        yield* opencode.plugin.list({ location: ref })
+        yield* Deferred.await(recommitted).pipe(Effect.timeout("5 seconds"))
+
+        expect((yield* opencode.plugin.list({ location: ref })).data.map((plugin) => String(plugin.id))).toContain(id)
+      }),
+    ),
+  15_000,
+)
+
 it.live(
  "keeps SDK plugin registration isolated between embedded hosts",
  () =>
@@ -2,13 +2,24 @@ import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import { Effect, Option, RcMap } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { Api } from "../api"
+import { requestRef } from "../location"

 export const DebugHandler = HttpApiBuilder.group(Api, "server.debug", (handlers) =>
-  handlers.handle(
-    "debug.location",
-    Effect.fn(function* () {
-      const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
-      return Array.from(yield* RcMap.keys(locations.rcMap))
-    }),
-  ),
+  handlers
+    .handle(
+      "debug.location",
+      Effect.fn(function* () {
+        const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
+        return Array.from(yield* RcMap.keys(locations.rcMap))
+      }),
+    )
+    .handle(
+      "debug.location.evict",
+      Effect.fn(function* (ctx) {
+        const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service))
+        // Resolve through requestRef so the key matches the shape the location
+        // middleware cached the services under.
+        yield* locations.invalidate(requestRef(ctx.request))
+      }),
+    ),
 )
@@ -2,45 +2,24 @@ import { MCP } from "@opencode-ai/core/mcp/index"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { Api } from "../api"
-import { McpServerNotFoundError } from "@opencode-ai/protocol/errors"
 import { response } from "../location"

 export const McpHandler = HttpApiBuilder.group(Api, "server.mcp", (handlers) =>
  Effect.gen(function* () {
-    return handlers
-      .handle(
-        "mcp.list",
-        Effect.fn(function* () {
-          const service = yield* MCP.Service
-          return yield* response(
-            service
-              .servers()
-              .pipe(
-                Effect.map((servers) =>
-                  servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })),
-                ),
+    return handlers.handle(
+      "mcp.list",
+      Effect.fn(function* () {
+        const service = yield* MCP.Service
+        return yield* response(
+          service
+            .servers()
+            .pipe(
+              Effect.map((servers) =>
+                servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })),
              ),
-          )
-        }),
-      )
-      .handle(
-        "mcp.resource.catalog",
-        Effect.fn(function* () {
-          const service = yield* MCP.Service
-          return yield* response(service.resourceCatalog())
-        }),
-      )
-      .handle(
-        "mcp.resource.read",
-        Effect.fn(function* (ctx) {
-          const service = yield* MCP.Service
-          return yield* response(
-            service.readResource({ server: ctx.payload.server, uri: ctx.payload.uri }).pipe(
-              Effect.map((result) => result ?? null),
-              Effect.mapError((error) => new McpServerNotFoundError({ server: error.server, message: error.message })),
            ),
-          )
-        }),
-      )
+        )
+      }),
+    )
  }),
 )
@@ -1,14 +1,9 @@
 export * as ServerProcess from "./process"

 import { NodeHttpClient, NodeHttpServer } from "@effect/platform-node"
-import { Credential } from "@opencode-ai/core/credential"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { PermissionSaved } from "@opencode-ai/core/permission/saved"
-import { Project } from "@opencode-ai/core/project"
 import { HealthGroup } from "@opencode-ai/protocol/groups/health"
 import { Context, Effect, Layer, Option } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpClient, HttpClientRequest, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http"
 import { HttpApi, HttpApiClient } from "effect/unstable/httpapi"
 import { createServer } from "node:http"
 import { ServerAuth } from "./auth"
@@ -53,9 +48,11 @@ function listen(options: Options) {
 function bind(hostname: string, port: number, password: string) {
  const server = createServer()
  return Layer.build(
-    HttpRouter.serve(createRoutes(password), { disableListenLog: true }).pipe(
+    createRoutes(password).pipe(
+      Layer.flatMap((context) =>
+        HttpServer.serve(Context.get(context, HttpRouter.HttpRouter).asHttpEffect(), HttpMiddleware.logger),
+      ),
      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: hostname })),
-      Layer.provide(AppNodeBuilder.build(LayerNode.group([Credential.node, PermissionSaved.node, Project.node]))),
    ),
  ).pipe(
    Effect.tap(() => Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))),
@@ -19,7 +19,7 @@ import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { HttpRouter, HttpServer } from "effect/unstable/http"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Effect, Layer, Option } from "effect"
+import { Context, Effect, Layer, Option } from "effect"
 import { Api } from "./api"
 import { ServerAuth } from "./auth"
 import { handlers } from "./handlers"
@@ -40,6 +40,7 @@ const applicationServices = LayerNode.group([
  Project.node,
  SessionV2.node,
  PluginRuntime.providerNode,
+  SdkPlugins.node,
  PermissionSaved.node,
  PtyTicket.node,
  Credential.node,
@@ -55,26 +56,22 @@ export function createRoutes(password?: string) {
  )
 }

-export function createEmbeddedRoutes(sdkPlugins?: SdkPlugins.Store) {
-  return makeRoutes(ServerAuth.Config.configLayer({ username: "opencode", password: Option.none() }), sdkPlugins)
+export function createEmbeddedRoutes() {
+  return makeRoutes(ServerAuth.Config.configLayer({ username: "opencode", password: Option.none() }))
 }

-function makeRoutes<AuthError, AuthServices>(
-  auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>,
-  sdkPlugins?: SdkPlugins.Store,
-) {
+function makeRoutes<AuthError, AuthServices>(auth: Layer.Layer<ServerAuth.Config, AuthError, AuthServices>) {
  const pluginRuntimeCell = PluginRuntime.makeCell()
  const replacements: LayerNode.Replacements = [
    [SessionExecution.node, SessionExecutionLocal.node],
    [PluginRuntime.node, PluginRuntime.layerWithCell(pluginRuntimeCell)],
    [PluginRuntime.providerNode, PluginRuntime.providerNodeWithCell(pluginRuntimeCell)],
-    ...(sdkPlugins ? [[SdkPlugins.node, SdkPlugins.layerWithStore(sdkPlugins)] as const] : []),
  ]
  const serviceLayer = simulateEnabled()
    ? Layer.unwrap(
        Effect.gen(function* () {
-          const { simulationReplacements, startDriveServer } = yield* Effect.promise(() =>
-            import("@opencode-ai/simulation/backend"),
+          const { simulationReplacements, startDriveServer } = yield* Effect.promise(
+            () => import("@opencode-ai/simulation/backend"),
          )
          if (driveEnabled()) startDriveServer()
          return AppNodeBuilder.build(applicationServices, [
@@ -85,16 +82,24 @@ function makeRoutes<AuthError, AuthServices>(
      )
    : AppNodeBuilder.build(applicationServices, replacements)

-  return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
-    Layer.provide(handlers.pipe(Layer.provide(serviceLayer))),
-    Layer.provide(formLocationLayer),
-    Layer.provide(sessionLocationLayer),
-    Layer.provide(layer),
-    Layer.provide(authorizationLayer),
-    Layer.provide(schemaErrorLayer),
-    Layer.provide(auth),
-    Layer.provide(serviceLayer),
-    Layer.provide(Observability.layer),
+  return serviceLayer.pipe(
+    Layer.flatMap((context) => {
+      const services = Layer.succeedContext(context)
+      const requestServices = Layer.succeedContext(Context.pick(PermissionSaved.Service, Project.Service)(context))
+      return HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(
+        Layer.provide(handlers.pipe(Layer.provide(services))),
+        Layer.provide(formLocationLayer),
+        Layer.provide(sessionLocationLayer),
+        Layer.provide(layer),
+        Layer.provide(authorizationLayer),
+        Layer.provide(schemaErrorLayer),
+        Layer.provide(auth),
+        Layer.provide(Observability.layer),
+        HttpRouter.provideRequest(requestServices),
+        Layer.provideMerge(services),
+        Layer.provideMerge(HttpRouter.layer),
+      )
+    }),
  )
 }

@@ -108,5 +113,4 @@ function driveEnabled() {

 export const routes = createRoutes()

-export const webHandler = () =>
-  HttpRouter.toWebHandler(routes.pipe(Layer.provide(HttpServer.layerServices)))
+export const webHandler = () => HttpRouter.toWebHandler(routes.pipe(Layer.provide(HttpServer.layerServices)))
@@ -16,6 +16,7 @@
    "typecheck": "tsgo --noEmit"
  },
  "dependencies": {
+    "@napi-rs/canvas": "1.0.2",
    "@opencode-ai/core": "workspace:*",
    "@opencode-ai/llm": "workspace:*",
    "@opentui/core": "catalog:",
@@ -1,7 +1,6 @@
 import { Effect } from "effect"
 import { SimulationProtocol } from "../protocol"
 import { SimulationLLMExchange } from "./llm-exchange"
-import { SimulationNetwork } from "./network"

 /**
 * Backend-hosted simulation control WebSocket.
@@ -19,16 +18,15 @@ import { SimulationNetwork } from "./network"
 * - `llm.finish`  { id, reason? } finish an exchange
 * - `llm.disconnect` { id } abruptly terminate an exchange without a finish
 * - `llm.pending`                 list open exchanges
- * - `network.log`                 simulated network request log
 */

 type ControlSocket = Bun.ServerWebSocket<{ unsubscribe?: () => void }>

 function parseRequest(input: string | Buffer) {
-  return SimulationProtocol.JsonRpc.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
+  return SimulationProtocol.Backend.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
 }

-async function handle(socket: ControlSocket, request: SimulationProtocol.JsonRpc.Request): Promise<unknown> {
+async function handle(socket: ControlSocket, request: SimulationProtocol.Backend.Request): Promise<unknown> {
  switch (request.method) {
    case "llm.attach": {
      socket.data.unsubscribe?.()
@@ -38,31 +36,27 @@ async function handle(socket: ControlSocket, request: SimulationProtocol.JsonRpc
      return { attached: true }
    }
    case "llm.chunk": {
-      const params = await SimulationProtocol.Backend.decodeChunkParams(request.params)
      await Effect.runPromise(
        SimulationLLMExchange.push(
-          params.id,
-          params.items.map((item) => ({ type: "item", item }) as const),
+          request.params.id,
+          request.params.items.map((item) => ({ type: "item", item }) as const),
        ),
      )
      return { ok: true }
    }
    case "llm.finish": {
-      const params = await SimulationProtocol.Backend.decodeFinishParams(request.params)
-      await Effect.runPromise(SimulationLLMExchange.push(params.id, [{ type: "finish", reason: params.reason }]))
+      await Effect.runPromise(
+        SimulationLLMExchange.push(request.params.id, [{ type: "finish", reason: request.params.reason }]),
+      )
      return { ok: true }
    }
    case "llm.disconnect": {
-      const params = await SimulationProtocol.Backend.decodeDisconnectParams(request.params)
-      await Effect.runPromise(SimulationLLMExchange.disconnect(params.id))
+      await Effect.runPromise(SimulationLLMExchange.disconnect(request.params.id))
      return { ok: true }
    }
    case "llm.pending":
      return { exchanges: SimulationLLMExchange.pending() }
-    case "network.log":
-      return { entries: SimulationNetwork.log() }
  }
-  throw new Error(`Unknown simulation control method: ${request.method}`)
 }

 export function start(endpoint: string) {
@@ -79,7 +73,7 @@ export function start(endpoint: string) {
        socket.data.unsubscribe?.()
      },
      async message(socket, message) {
-        let request: SimulationProtocol.JsonRpc.Request | undefined
+        let request: SimulationProtocol.Backend.Request | undefined
        try {
          request = parseRequest(message)
          const result = await handle(socket, request)
@@ -1,8 +1,11 @@
-import type { CliRenderer, Renderable } from "@opentui/core"
+import { mkdtemp } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import type { CapturedFrame, CliRenderer, Renderable } from "@opentui/core"
 import { createMockKeys, createMockMouse, type MockInput, type MockMouse } from "@opentui/core/testing"
 import type { SimulationProtocol } from "../protocol"
 import { SimulationRenderer } from "./renderer"
-import { SimulationTrace } from "./trace"
+import { SimulationPng } from "./png"

 export type Action = SimulationProtocol.Frontend.Action
 export type Element = SimulationProtocol.Frontend.Element
@@ -47,7 +50,7 @@ function hit(renderer: CliRenderer, renderable: Renderable) {
 /**
 * Builds the harness the simulation server drives.
 *
- * When the renderer is the fake simulation renderer, its TestRendererSetup
+ * When the renderer is the headless simulation renderer, its TestRendererSetup
 * provides the supported testing APIs. For the visible terminal renderer the
 * harness falls back to `requestRender` + `idle` and reading the private
 * `currentRenderBuffer`.
@@ -91,57 +94,95 @@ export function elements(renderer: CliRenderer): Element[] {
    .filter((element) => element.focusable || element.clickable || element.editor)
 }

-export function actions(renderer: CliRenderer, options: { text?: string } = {}): Action[] {
-  const items = elements(renderer)
-  return [
-    ...(renderer.currentFocusedEditor
-      ? ([{ type: "typeText", text: options.text ?? "hello" }, { type: "pressEnter" }] satisfies Action[])
-      : []),
-    ...items.filter((item) => item.focusable && !item.focused).map((item) => ({ type: "focus" as const, target: item.num })),
-    ...items
-      .filter((item) => item.clickable)
-      .map((item) => ({
-        type: "click" as const,
-        target: item.num,
-        x: Math.floor(item.x + item.width / 2),
-        y: Math.floor(item.y + item.height / 2),
-      })),
-    { type: "pressArrow", direction: "down" },
-    { type: "pressArrow", direction: "up" },
-  ]
-}
-
 export function state(harness: Harness) {
  return {
-    screen: harness.screen(),
    focused: {
      renderable: harness.renderer.currentFocusedRenderable?.num,
      editor: Boolean(harness.renderer.currentFocusedEditor),
    },
    elements: elements(harness.renderer),
-    actions: actions(harness.renderer),
  }
 }

+export async function screenshot(harness: Harness) {
+  await harness.renderOnce()
+  const image = SimulationPng.screenshot(harness.renderer)
+  const path = join(await mkdtemp(join(tmpdir(), "opencode-drive-")), "screenshot.png")
+  await Bun.write(path, image.data)
+  return path
+}
+
+export function frame(harness: Harness): CapturedFrame {
+  const buffer = harness.renderer.currentRenderBuffer
+  return {
+    cols: buffer.width,
+    rows: buffer.height,
+    cursor: [0, 0],
+    lines: buffer.getSpanLines().map((line) => ({
+      spans: line.spans.map((span) => ({
+        text: span.text,
+        fg: span.fg,
+        bg: span.bg,
+        attributes: span.attributes,
+        width: span.width,
+      })),
+    })),
+  }
+}
+
+export async function video(frames: CapturedFrame[]) {
+  const directory = await mkdtemp(join(tmpdir(), "opencode-drive-recording-"))
+  await Promise.all(
+    frames.map((frame, index) =>
+      Bun.write(
+        join(directory, `frame-${index.toString().padStart(6, "0")}.png`),
+        SimulationPng.screenshotFrame(frame).data,
+      ),
+    ),
+  )
+  const path = join(directory, "recording.mp4")
+  const process = Bun.spawn(
+    [
+      "ffmpeg",
+      "-loglevel",
+      "error",
+      "-framerate",
+      "10",
+      "-i",
+      join(directory, "frame-%06d.png"),
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-movflags",
+      "+faststart",
+      "-y",
+      path,
+    ],
+    { stderr: "pipe" },
+  )
+  if ((await process.exited) !== 0) throw new Error(`ffmpeg failed: ${await new Response(process.stderr).text()}`)
+  return path
+}
+
 export async function execute(harness: Harness, action: Action) {
-  SimulationTrace.add("ui.action", { action })
  switch (action.type) {
-    case "typeText":
+    case "ui.type":
      await harness.mockInput.typeText(action.text)
      break
-    case "pressKey":
+    case "ui.press":
      harness.mockInput.pressKey(action.key, action.modifiers)
      break
-    case "pressEnter":
+    case "ui.enter":
      harness.mockInput.pressEnter()
      break
-    case "pressArrow":
+    case "ui.arrow":
      harness.mockInput.pressArrow(action.direction)
      break
-    case "focus":
+    case "ui.focus":
      all(harness.renderer.root).find((item) => item.num === action.target)?.focus()
      break
-    case "click":
+    case "ui.click":
      await harness.mockMouse.click(action.x, action.y)
      break
  }
@@ -0,0 +1,84 @@
+import { fileURLToPath } from "node:url"
+import { GlobalFonts, createCanvas } from "@napi-rs/canvas"
+import { TextAttributes, type CapturedFrame, type CliRenderer, type RGBA } from "@opentui/core"
+
+const CellWidth = 10
+const CellHeight = 20
+const FontSize = 16
+const FontFamily = "OpenCode Screenshot"
+
+GlobalFonts.registerFromPath(
+  fileURLToPath(new URL("../../../ui/src/assets/fonts/JetBrainsMonoNerdFontMono-Regular.woff2", import.meta.url)),
+  FontFamily,
+)
+
+export function screenshot(renderer: CliRenderer) {
+  return screenshotFrame({
+    cols: renderer.currentRenderBuffer.width,
+    rows: renderer.currentRenderBuffer.height,
+    cursor: [0, 0],
+    lines: renderer.currentRenderBuffer.getSpanLines(),
+  })
+}
+
+export function screenshotFrame(frame: CapturedFrame) {
+  const canvas = createCanvas(frame.cols * CellWidth, frame.rows * CellHeight)
+  const context = canvas.getContext("2d")
+  context.fillStyle = "#080808"
+  context.fillRect(0, 0, canvas.width, canvas.height)
+  context.textBaseline = "top"
+
+  frame.lines.forEach((line, row) => {
+    let column = 0
+    line.spans.forEach((span) => {
+      const attributes = span.attributes & 0xff
+      const inverse = Boolean(attributes & TextAttributes.INVERSE)
+      const hidden = Boolean(attributes & TextAttributes.HIDDEN)
+      const foreground = inverse ? span.bg : span.fg
+      const background = inverse ? span.fg : span.bg
+      const chars = [...span.text]
+      let remaining = span.width
+
+      chars.forEach((char, index) => {
+        const cells = Math.max(1, remaining - (chars.length - index - 1))
+        if (background.a) {
+          context.fillStyle = color(background)
+          context.fillRect(column * CellWidth, row * CellHeight, cells * CellWidth, CellHeight)
+        }
+        if (!hidden && char.codePointAt(0) !== 0x0a00) {
+          context.fillStyle = color(foreground, attributes & TextAttributes.DIM ? 0.55 : 1)
+          context.font = `${attributes & TextAttributes.ITALIC ? "italic " : ""}${attributes & TextAttributes.BOLD ? "bold " : ""}${FontSize}px "${FontFamily}"`
+          context.fillText(char, column * CellWidth, row * CellHeight + 1)
+          if (attributes & TextAttributes.UNDERLINE) {
+            context.fillRect(column * CellWidth, row * CellHeight + 17, cells * CellWidth, 1)
+          }
+          if (attributes & TextAttributes.STRIKETHROUGH) {
+            context.fillRect(column * CellWidth, row * CellHeight + 10, cells * CellWidth, 1)
+          }
+        }
+        column += cells
+        remaining -= cells
+      })
+      while (remaining-- > 0) {
+        if (background.a) {
+          context.fillStyle = color(background)
+          context.fillRect(column * CellWidth, row * CellHeight, CellWidth, CellHeight)
+        }
+        column++
+      }
+    })
+  })
+
+  return {
+    width: canvas.width,
+    height: canvas.height,
+    data: canvas.toBuffer("image/png"),
+  }
+}
+
+function color(value: RGBA, opacity = 1) {
+  const [red, green, blue, alpha] = value.toInts()
+  return `rgba(${red}, ${green}, ${blue}, ${(alpha / 255) * opacity})`
+}
+
+export * as SimulationPng from "./png"
@@ -4,7 +4,7 @@ import { createTestRenderer, type TestRendererSetup } from "@opentui/core/testin
 const setups = new WeakMap<CliRenderer, TestRendererSetup>()

 /**
- * Creates the fake simulation renderer: a real CliRenderer backed by an
+ * Creates the headless simulation renderer: a real CliRenderer backed by an
 * in-memory screen buffer instead of a terminal. The TestRendererSetup is
 * kept module-side (keyed by renderer) so the harness can use the supported
 * testing APIs without app code carrying it around.
@@ -1,67 +1,100 @@
+import type { CapturedFrame } from "@opentui/core"
 import { SimulationProtocol } from "../protocol"
 import { SimulationActions, type Harness } from "./actions"
-import { SimulationTrace } from "./trace"

 export interface Server {
  readonly url: string
  readonly stop: () => void
 }

-function actionParam(params: unknown) {
-  return SimulationProtocol.Frontend.decodeActionParams(params).action
-}
-
 function parseRequest(input: string | Buffer) {
-  return SimulationProtocol.JsonRpc.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
+  return SimulationProtocol.Frontend.decodeRequest(JSON.parse(typeof input === "string" ? input : input.toString()))
 }

-async function handle(harness: Harness, request: SimulationProtocol.JsonRpc.Request) {
+interface Recording {
+  readonly frames: CapturedFrame[]
+  readonly timer: ReturnType<typeof setInterval>
+  pending: Promise<void>
+}
+
+async function handle(
+  harness: Harness,
+  request: SimulationProtocol.Frontend.Request,
+  recording: { current?: Recording },
+  headless: boolean,
+) {
  switch (request.method) {
+    case "ui.screenshot":
+      return SimulationActions.screenshot(harness)
    case "ui.state": {
-      const result = SimulationActions.state(harness)
-      SimulationTrace.add("ui.state", { elements: result.elements.length, actions: result.actions.length })
-      return result
+      return SimulationActions.state(harness)
    }
-    case "ui.action":
-      return SimulationActions.execute(harness, actionParam(request.params))
-    case "ui.render": {
-      await harness.renderOnce()
-      const result = SimulationActions.state(harness)
-      SimulationTrace.add("ui.render", { elements: result.elements.length, actions: result.actions.length })
-      return result
+    case "ui.start-record": {
+      if (recording.current) throw new Error("UI recording is already active")
+      const frames = [SimulationActions.frame(harness)]
+      const current: Recording = {
+        frames,
+        timer: setInterval(() => {
+          current.pending = current.pending.then(async () => {
+            if (headless) await harness.renderOnce()
+            frames.push(SimulationActions.frame(harness))
+          })
+        }, 100),
+        pending: Promise.resolve(),
+      }
+      recording.current = current
+      return { recording: true }
    }
-    case "trace.list":
-      return { records: SimulationTrace.list() }
-    case "trace.clear":
-      SimulationTrace.clear()
-      return { cleared: true }
-    case "trace.export":
-      return SimulationTrace.exportTrace()
+    case "ui.end-record": {
+      if (!recording.current) throw new Error("UI recording is not active")
+      const current = recording.current
+      clearInterval(current.timer)
+      await current.pending
+      if (headless) await harness.renderOnce()
+      current.frames.push(SimulationActions.frame(harness))
+      recording.current = undefined
+      return SimulationActions.video(current.frames)
+    }
+    case "ui.type":
+      return SimulationActions.execute(harness, { type: "ui.type", text: request.params.text })
+    case "ui.enter":
+      return SimulationActions.execute(harness, { type: "ui.enter" })
+    case "ui.press":
+      return SimulationActions.execute(harness, {
+        type: "ui.press",
+        key: request.params.key,
+        modifiers: request.params.modifiers,
+      })
+    case "ui.arrow":
+      return SimulationActions.execute(harness, { type: "ui.arrow", direction: request.params.direction })
+    case "ui.focus":
+      return SimulationActions.execute(harness, { type: "ui.focus", target: request.params.target })
+    case "ui.click":
+      return SimulationActions.execute(harness, {
+        type: "ui.click",
+        target: request.params.target,
+        x: request.params.x,
+        y: request.params.y,
+      })
  }
-  throw new Error(`Unknown simulation method: ${request.method}`)
 }

-export function start(harness: Harness, endpoint: string): Server {
+export function start(harness: Harness, endpoint: string, headless: boolean): Server {
  const url = new URL(endpoint)
-  const server = Bun.serve<{ readonly drive: true }>({
+  const recording: { current?: Recording } = {}
+  const server = Bun.serve<{ readonly drive: true; readonly headless: boolean }>({
    hostname: url.hostname,
    port: Number(url.port),
    fetch(request, server) {
-      if (server.upgrade(request, { data: { drive: true } })) return undefined
+      if (server.upgrade(request, { data: { drive: true, headless } })) return undefined
      return new Response("opencode drive ui websocket", { status: 426 })
    },
    websocket: {
-      open() {
-        SimulationTrace.add("control.connect")
-      },
-      close() {
-        SimulationTrace.add("control.disconnect")
-      },
      async message(socket, message) {
-        let request: SimulationProtocol.JsonRpc.Request | undefined
+        let request: SimulationProtocol.Frontend.Request | undefined
        try {
          request = parseRequest(message)
-          const result = await handle(harness, request)
+          const result = await handle(harness, request, recording, headless)
          const next = SimulationProtocol.JsonRpc.success(request.id, result)
          if (next) socket.send(JSON.stringify(next))
        } catch (error) {
@@ -70,11 +103,10 @@ export function start(harness: Harness, endpoint: string): Server {
      },
    },
  })
-  SimulationTrace.add("control.start", { url: endpoint })
  return {
    url: endpoint,
    stop: () => {
-      SimulationTrace.add("control.stop", { url: endpoint })
+      if (recording.current) clearInterval(recording.current.timer)
      server.stop(true)
    },
  }
@@ -7,19 +7,18 @@ import { SimulationServer } from "./server"
 /**
 * Drive-mode renderer entry point.
 *
- * Creates the renderer (fake when OPENCODE_DRIVE_RENDERER=fake, the normal
+ * Creates the renderer (headless when OPENCODE_DRIVE_RENDERER=headless, the normal
 * visible renderer otherwise) and starts the UI control
 * server against it. The server stops when the renderer is destroyed, so the
 * caller only manages the renderer lifecycle.
 */
 export async function create(options: CliRendererConfig): Promise<CliRenderer> {
-  const renderer =
-    process.env.OPENCODE_DRIVE_RENDERER === "fake"
-      ? await SimulationRenderer.create(options)
-      : await createCliRenderer(options)
+  const headless = process.env.OPENCODE_DRIVE_RENDERER === "headless"
+  const renderer = headless ? await SimulationRenderer.create(options) : await createCliRenderer(options)
  const server = SimulationServer.start(
    SimulationActions.createHarness(renderer),
    DriveManifest.resolve().endpoints.ui,
+    headless,
  )
  process.stderr.write(`opencode drive ui websocket: ${server.url}\n`)
  renderer.once("destroy", () => server.stop())
@@ -1,37 +0,0 @@
-export type TraceRecord = {
-  readonly id: number
-  readonly time: string
-  readonly type: string
-  readonly data?: unknown
-}
-
-const records: TraceRecord[] = []
-let nextID = 0
-
-export function add(type: string, data?: unknown) {
-  const record = {
-    id: ++nextID,
-    time: new Date().toISOString(),
-    type,
-    ...(data === undefined ? {} : { data }),
-  } satisfies TraceRecord
-  records.push(record)
-  return record
-}
-
-export function list() {
-  return [...records]
-}
-
-export function clear() {
-  records.length = 0
-  nextID = 0
-}
-
-export function exportTrace() {
-  return {
-    records: list(),
-  }
-}
-
-export * as SimulationTrace from "./trace"
@@ -4,9 +4,12 @@ const JsonRpcID = Schema.Union([Schema.String, Schema.Number, Schema.Null])
 type Json = Schema.Schema.Type<typeof Schema.Json>

 export namespace JsonRpc {
-  export const Request = Schema.Struct({
+  export const RequestFields = {
    jsonrpc: Schema.Literal("2.0"),
    id: Schema.optional(JsonRpcID),
+  }
+  export const Request = Schema.Struct({
+    ...RequestFields,
    method: Schema.String,
    params: Schema.optional(Schema.Json),
  })
@@ -56,12 +59,12 @@ export namespace Frontend {
  export interface KeyModifiers extends Schema.Schema.Type<typeof KeyModifiers> {}

  export const Action = Schema.Union([
-    Schema.Struct({ type: Schema.Literal("typeText"), text: Schema.String }),
-    Schema.Struct({ type: Schema.Literal("pressKey"), key: Schema.String, modifiers: Schema.optional(KeyModifiers) }),
-    Schema.Struct({ type: Schema.Literal("pressEnter") }),
-    Schema.Struct({ type: Schema.Literal("pressArrow"), direction: Schema.Literals(["up", "down", "left", "right"]) }),
-    Schema.Struct({ type: Schema.Literal("focus"), target: Schema.Number }),
-    Schema.Struct({ type: Schema.Literal("click"), target: Schema.Number, x: Schema.Number, y: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("ui.type"), text: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("ui.press"), key: Schema.String, modifiers: Schema.optional(KeyModifiers) }),
+    Schema.Struct({ type: Schema.Literal("ui.enter") }),
+    Schema.Struct({ type: Schema.Literal("ui.arrow"), direction: Schema.Literals(["up", "down", "left", "right"]) }),
+    Schema.Struct({ type: Schema.Literal("ui.focus"), target: Schema.Number }),
+    Schema.Struct({ type: Schema.Literal("ui.click"), target: Schema.Number, x: Schema.Number, y: Schema.Number }),
  ])
  export type Action = Schema.Schema.Type<typeof Action>

@@ -80,30 +83,58 @@ export namespace Frontend {
  export interface Element extends Schema.Schema.Type<typeof Element> {}

  export const State = Schema.Struct({
-    screen: Schema.String,
    focused: Schema.Struct({
      renderable: Schema.optional(Schema.Number),
      editor: Schema.Boolean,
    }),
    elements: Schema.Array(Element),
-    actions: Schema.Array(Action),
  })
  export interface State extends Schema.Schema.Type<typeof State> {}

-  export const ActionParams = Schema.Struct({ action: Action })
-  export interface ActionParams extends Schema.Schema.Type<typeof ActionParams> {}
-  export const decodeActionParams = Schema.decodeUnknownSync(ActionParams)
+  export const Screenshot = Schema.String
+  export type Screenshot = Schema.Schema.Type<typeof Screenshot>

-  export const TraceRecord = Schema.Struct({
-    id: Schema.Number,
-    time: Schema.String,
-    type: Schema.String,
-    data: Schema.optional(Schema.Json),
-  })
-  export interface TraceRecord extends Schema.Schema.Type<typeof TraceRecord> {}
+  export const StartRecord = Schema.Struct({ recording: Schema.Literal(true) })
+  export interface StartRecord extends Schema.Schema.Type<typeof StartRecord> {}
+
+  export const EndRecord = Schema.String
+  export type EndRecord = Schema.Schema.Type<typeof EndRecord>
+
+  export const TypeParams = Schema.Struct({ text: Schema.String })
+  export interface TypeParams extends Schema.Schema.Type<typeof TypeParams> {}
+
+  export const PressParams = Schema.Struct({ key: Schema.String, modifiers: Schema.optional(KeyModifiers) })
+  export interface PressParams extends Schema.Schema.Type<typeof PressParams> {}
+
+  export const ArrowParams = Schema.Struct({ direction: Schema.Literals(["up", "down", "left", "right"]) })
+  export interface ArrowParams extends Schema.Schema.Type<typeof ArrowParams> {}
+
+  export const FocusParams = Schema.Struct({ target: Schema.Number })
+  export interface FocusParams extends Schema.Schema.Type<typeof FocusParams> {}
+
+  export const ClickParams = Schema.Struct({ target: Schema.Number, x: Schema.Number, y: Schema.Number })
+  export interface ClickParams extends Schema.Schema.Type<typeof ClickParams> {}
+
+  export const Request = Schema.Union([
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.type"), params: TypeParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.press"), params: PressParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.arrow"), params: ArrowParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.focus"), params: FocusParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("ui.click"), params: ClickParams }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literals([
+        "ui.enter",
+        "ui.screenshot",
+        "ui.state",
+        "ui.start-record",
+        "ui.end-record",
+      ]),
+    }),
+  ])
+  export type Request = Schema.Schema.Type<typeof Request>
+  export const decodeRequest = Schema.decodeUnknownSync(Request)

-  export const TraceList = Schema.Struct({ records: Schema.Array(TraceRecord) })
-  export interface TraceList extends Schema.Schema.Type<typeof TraceList> {}
 }

 export namespace Backend {
@@ -130,6 +161,18 @@ export namespace Backend {
  export const DisconnectParams = Schema.Struct({ id: Schema.String })
  export interface DisconnectParams extends Schema.Schema.Type<typeof DisconnectParams> {}

+  export const Request = Schema.Union([
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.chunk"), params: ChunkParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.finish"), params: FinishParams }),
+    Schema.Struct({ ...JsonRpc.RequestFields, method: Schema.Literal("llm.disconnect"), params: DisconnectParams }),
+    Schema.Struct({
+      ...JsonRpc.RequestFields,
+      method: Schema.Literals(["llm.attach", "llm.pending"]),
+    }),
+  ])
+  export type Request = Schema.Schema.Type<typeof Request>
+  export const decodeRequest = Schema.decodeUnknownSync(Request)
+
  export const OpenedExchange = Schema.Struct({ id: Schema.String, url: Schema.String, body: Schema.Json })
  export interface OpenedExchange extends Schema.Schema.Type<typeof OpenedExchange> {}

@@ -141,9 +184,6 @@ export namespace Backend {
  })
  export interface NetworkLogEntry extends Schema.Schema.Type<typeof NetworkLogEntry> {}

-  export const decodeChunkParams = Schema.decodeUnknownPromise(ChunkParams)
-  export const decodeFinishParams = Schema.decodeUnknownPromise(FinishParams)
-  export const decodeDisconnectParams = Schema.decodeUnknownPromise(DisconnectParams)
 }

 export * as SimulationProtocol from "./index"
@@ -832,7 +832,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
            const messages = [
              ...loaded.map((message) => {
                if (message.type === "user") return message
-                return liveByID.get(message.id) ?? message
+                const live = liveByID.get(message.id)
+                if (!live || ("completed" in message.time && message.time.completed !== undefined)) return message
+                return live
              }),
              ...live.filter((message) => !loadedIDs.has(message.id)),
            ].toSorted((a, b) => a.time.created - b.time.created)
@@ -166,6 +166,115 @@ test("restores running manual compaction before applying live deltas", async ()
  }
 })

+test("refresh replaces stale completed messages with the terminal server projection", async () => {
+  const events = createEventStream()
+  const sessionID = "session-stale-tool"
+  const messageID = "message-stale-tool"
+  const calls = createFetch((url) => {
+    if (url.pathname === `/api/session/${sessionID}/message`)
+      return json({
+        data: [
+          {
+            id: messageID,
+            type: "assistant",
+            agent: "build",
+            model: { id: "model", providerID: "provider" },
+            content: [
+              {
+                type: "tool",
+                id: "call-write",
+                name: "write",
+                provider: { executed: false },
+                state: {
+                  status: "error",
+                  input: {},
+                  content: [],
+                  structured: {},
+                  error: { type: "unknown", message: "Tool execution interrupted" },
+                },
+                time: { created: 1, completed: 3 },
+              },
+            ],
+            finish: "error",
+            error: { type: "unknown", message: "Step interrupted" },
+            time: { created: 1, completed: 3 },
+          },
+        ],
+        cursor: {},
+      })
+    return undefined
+  }, events)
+  let data!: ReturnType<typeof useData>
+
+  function Probe() {
+    data = useData()
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider client={createClient(calls.fetch)} api={createApi(calls.fetch)}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    emitEvent(events, {
+      id: "evt_step_started_stale_tool",
+      created: 1,
+      type: "session.step.started",
+      durable: durable(sessionID),
+      data: {
+        sessionID,
+        assistantMessageID: messageID,
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+      },
+    })
+    emitEvent(events, {
+      id: "evt_tool_started_stale_tool",
+      created: 2,
+      type: "session.tool.input.started",
+      durable: durable(sessionID, 1),
+      data: {
+        sessionID,
+        assistantMessageID: messageID,
+        callID: "call-write",
+        name: "write",
+      },
+    })
+    emitEvent(events, {
+      id: "evt_step_failed_stale_tool",
+      created: 3,
+      type: "session.step.failed",
+      durable: durable(sessionID, 2),
+      data: {
+        sessionID,
+        assistantMessageID: messageID,
+        error: { type: "unknown", message: "Step interrupted" },
+      },
+    })
+
+    await wait(() => {
+      const message = data.session.message.get(sessionID, messageID)
+      return message?.type === "assistant" && message.time.completed === 3
+    })
+    await data.session.message.refresh(sessionID)
+
+    const message = data.session.message.get(sessionID, messageID)
+    expect(message?.type).toBe("assistant")
+    if (message?.type !== "assistant") return
+    expect(message.content[0]).toMatchObject({ type: "tool", state: { status: "error" } })
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("reconnects the event stream and bootstraps fresh data", async () => {
  const events = createEventStream()
  const requests = { active: 0, event: 0, model: 0 }
Author	SHA1	Message	Date
Kit Langton	ac2e4b2d96	fix(tui): clear stale tool preparation state Prefer the terminal server projection when refresh observes a completed assistant message, so a missed tool-failure event cannot leave the TUI showing an uncancellable pending tool. Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>	2026-07-07 20:01:37 +00:00
opencode-agent[bot]	d0733f83bf	fix(codemode): return final top-level expression (#35759 ) Co-authored-by: Kit Langton <kit.langton@gmail.com>	2026-07-07 11:44:50 -05:00
Kit Langton	b2ce195bda	fix(core): normalize Location.Ref keys in LocationServiceMap (#35757 )	2026-07-07 12:25:29 -04:00
James Long	6c065ca6a5	feat(simulation): render driven UI screenshots and videos (#35739 )	2026-07-07 12:15:01 -04:00
Dax Raad	dd1c007877	docs	2026-07-07 12:08:45 -04:00
Kit Langton	8deb0e5780	fix(core): preserve SDK plugins across location eviction (#35725 )	2026-07-07 11:43:40 -04:00
Aiden Cline	f488089179	fix: preserve compaction files and classify Z.AI overflow (#35747 ) Co-authored-by: opencode-agent[bot] <219766164+opencode-agent[bot]@users.noreply.github.com> Co-authored-by: 冯基魁 <56265583+fengjikui@users.noreply.github.com>	2026-07-07 09:54:31 -05:00
Kit Langton	e3a39b214f	fix(core): lower failed reasoning to text (#35735 )	2026-07-07 09:49:17 -04:00
James Long	b6a2912bb1	refactor(simulation): type RPC request payloads (#35734 )	2026-07-07 09:21:19 -04:00