docs(codemode): clarify output byte budget

fix(codemode): preserve floating rejection results
fix(codemode): release settled promise state
2026-07-08 13:50:31 -05:00 · 2026-07-08 12:02:27 -05:00 · 2026-07-07 16:03:59 -05:00 · 2026-07-07 15:58:08 -05:00 · 2026-07-07 14:01:28 -05:00 · 2026-07-07 14:49:11 -04:00
79 changed files with 2830 additions and 963 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") {
@@ -111,157 +111,167 @@ export type Endpoint4_8Input = {
 export type Endpoint4_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>
 export type SessionRenameOperation<E = never> = (input: Endpoint4_8Input) => Effect.Effect<Endpoint4_8Output, E>

-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
 export type Endpoint4_9Input = {
  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly id?: Endpoint4_9Request["payload"]["id"]
-  readonly prompt: Endpoint4_9Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_9Request["payload"]["resume"]
+  readonly destination: Endpoint4_9Request["payload"]["destination"]
+  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
 }
-export type Endpoint4_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
-export type SessionPromptOperation<E = never> = (input: Endpoint4_9Input) => Effect.Effect<Endpoint4_9Output, E>
+export type Endpoint4_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
+export type SessionMoveOperation<E = never> = (input: Endpoint4_9Input) => Effect.Effect<Endpoint4_9Output, E>

-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
 export type Endpoint4_10Input = {
  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly command: Endpoint4_10Request["payload"]["command"]
-  readonly arguments?: Endpoint4_10Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_10Request["payload"]["agent"]
-  readonly model?: Endpoint4_10Request["payload"]["model"]
-  readonly files?: Endpoint4_10Request["payload"]["files"]
-  readonly agents?: Endpoint4_10Request["payload"]["agents"]
+  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
  readonly resume?: Endpoint4_10Request["payload"]["resume"]
 }
-export type Endpoint4_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
-export type SessionCommandOperation<E = never> = (input: Endpoint4_10Input) => Effect.Effect<Endpoint4_10Output, E>
+export type Endpoint4_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
+export type SessionPromptOperation<E = never> = (input: Endpoint4_10Input) => Effect.Effect<Endpoint4_10Output, E>

-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
 export type Endpoint4_11Input = {
  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
  readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly skill: Endpoint4_11Request["payload"]["skill"]
+  readonly command: Endpoint4_11Request["payload"]["command"]
+  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_11Request["payload"]["agent"]
+  readonly model?: Endpoint4_11Request["payload"]["model"]
+  readonly files?: Endpoint4_11Request["payload"]["files"]
+  readonly agents?: Endpoint4_11Request["payload"]["agents"]
+  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
  readonly resume?: Endpoint4_11Request["payload"]["resume"]
 }
-export type Endpoint4_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
-export type SessionSkillOperation<E = never> = (input: Endpoint4_11Input) => Effect.Effect<Endpoint4_11Output, E>
+export type Endpoint4_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
+export type SessionCommandOperation<E = never> = (input: Endpoint4_11Input) => Effect.Effect<Endpoint4_11Output, E>

-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
 export type Endpoint4_12Input = {
  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly text: Endpoint4_12Request["payload"]["text"]
-  readonly description?: Endpoint4_12Request["payload"]["description"]
-  readonly metadata?: Endpoint4_12Request["payload"]["metadata"]
+  readonly id?: Endpoint4_12Request["payload"]["id"]
+  readonly skill: Endpoint4_12Request["payload"]["skill"]
+  readonly resume?: Endpoint4_12Request["payload"]["resume"]
 }
-export type Endpoint4_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
-export type SessionSyntheticOperation<E = never> = (input: Endpoint4_12Input) => Effect.Effect<Endpoint4_12Output, E>
+export type Endpoint4_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
+export type SessionSkillOperation<E = never> = (input: Endpoint4_12Input) => Effect.Effect<Endpoint4_12Output, E>

-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
 export type Endpoint4_13Input = {
  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly id?: Endpoint4_13Request["payload"]["id"]
-  readonly command: Endpoint4_13Request["payload"]["command"]
+  readonly text: Endpoint4_13Request["payload"]["text"]
+  readonly description?: Endpoint4_13Request["payload"]["description"]
+  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
+  readonly resume?: Endpoint4_13Request["payload"]["resume"]
 }
-export type Endpoint4_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
-export type SessionShellOperation<E = never> = (input: Endpoint4_13Input) => Effect.Effect<Endpoint4_13Output, E>
+export type Endpoint4_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
+export type SessionSyntheticOperation<E = never> = (input: Endpoint4_13Input) => Effect.Effect<Endpoint4_13Output, E>

-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
 export type Endpoint4_14Input = {
  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
  readonly id?: Endpoint4_14Request["payload"]["id"]
+  readonly command: Endpoint4_14Request["payload"]["command"]
 }
-export type Endpoint4_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
-export type SessionCompactOperation<E = never> = (input: Endpoint4_14Input) => Effect.Effect<Endpoint4_14Output, E>
+export type Endpoint4_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
+export type SessionShellOperation<E = never> = (input: Endpoint4_14Input) => Effect.Effect<Endpoint4_14Output, E>

-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-export type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
-export type Endpoint4_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
-export type SessionWaitOperation<E = never> = (input: Endpoint4_15Input) => Effect.Effect<Endpoint4_15Output, E>
-
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-export type Endpoint4_16Input = {
-  readonly sessionID: Endpoint4_16Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_16Request["payload"]["messageID"]
-  readonly files?: Endpoint4_16Request["payload"]["files"]
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+export type Endpoint4_15Input = {
+  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
+  readonly id?: Endpoint4_15Request["payload"]["id"]
 }
-export type Endpoint4_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
-export type SessionRevertStageOperation<E = never> = (input: Endpoint4_16Input) => Effect.Effect<Endpoint4_16Output, E>
+export type Endpoint4_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
+export type SessionCompactOperation<E = never> = (input: Endpoint4_15Input) => Effect.Effect<Endpoint4_15Output, E>

-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-export type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
-export type Endpoint4_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
-export type SessionRevertClearOperation<E = never> = (input: Endpoint4_17Input) => Effect.Effect<Endpoint4_17Output, E>
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+export type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
+export type Endpoint4_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
+export type SessionWaitOperation<E = never> = (input: Endpoint4_16Input) => Effect.Effect<Endpoint4_16Output, E>

-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+export type Endpoint4_17Input = {
+  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
+  readonly files?: Endpoint4_17Request["payload"]["files"]
+}
+export type Endpoint4_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
+export type SessionRevertStageOperation<E = never> = (input: Endpoint4_17Input) => Effect.Effect<Endpoint4_17Output, E>
+
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 export type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-export type Endpoint4_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint4_18Input) => Effect.Effect<Endpoint4_18Output, E>
+export type Endpoint4_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
+export type SessionRevertClearOperation<E = never> = (input: Endpoint4_18Input) => Effect.Effect<Endpoint4_18Output, E>

-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 export type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-export type Endpoint4_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
-export type SessionContextOperation<E = never> = (input: Endpoint4_19Input) => Effect.Effect<Endpoint4_19Output, E>
+export type Endpoint4_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint4_19Input) => Effect.Effect<Endpoint4_19Output, E>

-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
 export type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-export type Endpoint4_20Output = EffectValue<
+export type Endpoint4_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
+export type SessionContextOperation<E = never> = (input: Endpoint4_20Input) => Effect.Effect<Endpoint4_20Output, E>
+
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+export type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
+export type Endpoint4_21Output = EffectValue<
  ReturnType<RawClient["server.session"]["session.instructions.entry.list"]>
 >["data"]
 export type SessionInstructionsEntryListOperation<E = never> = (
-  input: Endpoint4_20Input,
-) => Effect.Effect<Endpoint4_20Output, E>
-
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-export type Endpoint4_21Input = {
-  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
-  readonly key: Endpoint4_21Request["params"]["key"]
-  readonly value: Endpoint4_21Request["payload"]["value"]
-}
-export type Endpoint4_21Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
-export type SessionInstructionsEntryPutOperation<E = never> = (
  input: Endpoint4_21Input,
 ) => Effect.Effect<Endpoint4_21Output, E>

-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
 export type Endpoint4_22Input = {
  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
  readonly key: Endpoint4_22Request["params"]["key"]
+  readonly value: Endpoint4_22Request["payload"]["value"]
 }
-export type Endpoint4_22Output = EffectValue<
-  ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
->
-export type SessionInstructionsEntryRemoveOperation<E = never> = (
+export type Endpoint4_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
+export type SessionInstructionsEntryPutOperation<E = never> = (
  input: Endpoint4_22Input,
 ) => Effect.Effect<Endpoint4_22Output, E>

-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
 export type Endpoint4_23Input = {
  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly after?: Endpoint4_23Request["query"]["after"]
-  readonly follow?: Endpoint4_23Request["query"]["follow"]
+  readonly key: Endpoint4_23Request["params"]["key"]
 }
-export type Endpoint4_23Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
-export type SessionLogOperation<E = never> = (input: Endpoint4_23Input) => Stream.Stream<Endpoint4_23Output, E>
+export type Endpoint4_23Output = EffectValue<
+  ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
+>
+export type SessionInstructionsEntryRemoveOperation<E = never> = (
+  input: Endpoint4_23Input,
+) => Effect.Effect<Endpoint4_23Output, E>

-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-export type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
-export type Endpoint4_24Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
-export type SessionInterruptOperation<E = never> = (input: Endpoint4_24Input) => Effect.Effect<Endpoint4_24Output, E>
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+export type Endpoint4_24Input = {
+  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
+  readonly after?: Endpoint4_24Request["query"]["after"]
+  readonly follow?: Endpoint4_24Request["query"]["follow"]
+}
+export type Endpoint4_24Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
+export type SessionLogOperation<E = never> = (input: Endpoint4_24Input) => Stream.Stream<Endpoint4_24Output, E>

-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
 export type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
-export type Endpoint4_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
-export type SessionBackgroundOperation<E = never> = (input: Endpoint4_25Input) => Effect.Effect<Endpoint4_25Output, E>
+export type Endpoint4_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
+export type SessionInterruptOperation<E = never> = (input: Endpoint4_25Input) => Effect.Effect<Endpoint4_25Output, E>

-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-export type Endpoint4_26Input = {
-  readonly sessionID: Endpoint4_26Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_26Request["params"]["messageID"]
+type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+export type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
+export type Endpoint4_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
+export type SessionBackgroundOperation<E = never> = (input: Endpoint4_26Input) => Effect.Effect<Endpoint4_26Output, E>
+
+type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+export type Endpoint4_27Input = {
+  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_27Request["params"]["messageID"]
 }
-export type Endpoint4_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
-export type SessionMessageOperation<E = never> = (input: Endpoint4_26Input) => Effect.Effect<Endpoint4_26Output, E>
+export type Endpoint4_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
+export type SessionMessageOperation<E = never> = (input: Endpoint4_27Input) => Effect.Effect<Endpoint4_27Output, E>

 export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
@@ -273,6 +283,7 @@ export interface SessionApi<E = never> {
  readonly switchAgent: SessionSwitchAgentOperation<E>
  readonly switchModel: SessionSwitchModelOperation<E>
  readonly rename: SessionRenameOperation<E>
+  readonly move: SessionMoveOperation<E>
  readonly prompt: SessionPromptOperation<E>
  readonly command: SessionCommandOperation<E>
  readonly skill: SessionSkillOperation<E>
@@ -439,8 +450,14 @@ 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 ServerMcpCatalogOperation<E = never> = (input?: Endpoint10_1Input) => Effect.Effect<Endpoint10_1Output, E>
+
 export interface ServerMcpApi<E = never> {
  readonly list: ServerMcpListOperation<E>
+  readonly catalog: ServerMcpCatalogOperation<E>
 }

 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
@@ -890,8 +907,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> {
@@ -141,15 +141,27 @@ const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Inp
    Effect.mapError(mapClientError),
  )

-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
 type Endpoint4_9Input = {
  readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly id?: Endpoint4_9Request["payload"]["id"]
-  readonly prompt: Endpoint4_9Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_9Request["payload"]["resume"]
+  readonly destination: Endpoint4_9Request["payload"]["destination"]
+  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
 }
 const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
+  raw["session.move"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { destination: input["destination"], moveChanges: input["moveChanges"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_10Input = {
+  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
+  readonly id?: Endpoint4_10Request["payload"]["id"]
+  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
+  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+}
+const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
  raw["session.prompt"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
@@ -158,20 +170,20 @@ const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Inp
    Effect.map((value) => value.data),
  )

-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-type Endpoint4_10Input = {
-  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
-  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly command: Endpoint4_10Request["payload"]["command"]
-  readonly arguments?: Endpoint4_10Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_10Request["payload"]["agent"]
-  readonly model?: Endpoint4_10Request["payload"]["model"]
-  readonly files?: Endpoint4_10Request["payload"]["files"]
-  readonly agents?: Endpoint4_10Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_10Request["payload"]["resume"]
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_11Input = {
+  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
+  readonly id?: Endpoint4_11Request["payload"]["id"]
+  readonly command: Endpoint4_11Request["payload"]["command"]
+  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_11Request["payload"]["agent"]
+  readonly model?: Endpoint4_11Request["payload"]["model"]
+  readonly files?: Endpoint4_11Request["payload"]["files"]
+  readonly agents?: Endpoint4_11Request["payload"]["agents"]
+  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_11Request["payload"]["resume"]
 }
-const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
+const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
  raw["session.command"]({
    params: { sessionID: input["sessionID"] },
    payload: {
@@ -190,67 +202,73 @@ const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10I
    Effect.map((value) => value.data),
  )

-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-type Endpoint4_11Input = {
-  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
-  readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly skill: Endpoint4_11Request["payload"]["skill"]
-  readonly resume?: Endpoint4_11Request["payload"]["resume"]
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_12Input = {
+  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
+  readonly id?: Endpoint4_12Request["payload"]["id"]
+  readonly skill: Endpoint4_12Request["payload"]["skill"]
+  readonly resume?: Endpoint4_12Request["payload"]["resume"]
 }
-const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
+const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
  raw["session.skill"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly text: Endpoint4_12Request["payload"]["text"]
-  readonly description?: Endpoint4_12Request["payload"]["description"]
-  readonly metadata?: Endpoint4_12Request["payload"]["metadata"]
-}
-const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
-  raw["session.synthetic"]({
-    params: { sessionID: input["sessionID"] },
-    payload: { text: input["text"], description: input["description"], metadata: input["metadata"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
 type Endpoint4_13Input = {
  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly id?: Endpoint4_13Request["payload"]["id"]
-  readonly command: Endpoint4_13Request["payload"]["command"]
+  readonly text: Endpoint4_13Request["payload"]["text"]
+  readonly description?: Endpoint4_13Request["payload"]["description"]
+  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
+  readonly resume?: Endpoint4_13Request["payload"]["resume"]
 }
 const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
+  raw["session.synthetic"]({
+    params: { sessionID: input["sessionID"] },
+    payload: {
+      text: input["text"],
+      description: input["description"],
+      metadata: input["metadata"],
+      resume: input["resume"],
+    },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_14Input = {
+  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
+  readonly id?: Endpoint4_14Request["payload"]["id"]
+  readonly command: Endpoint4_14Request["payload"]["command"]
+}
+const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
  raw["session.shell"]({
    params: { sessionID: input["sessionID"] },
    payload: { id: input["id"], command: input["command"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint4_14Input = {
-  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
-  readonly id?: Endpoint4_14Request["payload"]["id"]
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint4_15Input = {
+  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
+  readonly id?: Endpoint4_15Request["payload"]["id"]
 }
-const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
  raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
-const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
+const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
  raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint4_16Input = {
-  readonly sessionID: Endpoint4_16Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_16Request["payload"]["messageID"]
-  readonly files?: Endpoint4_16Request["payload"]["files"]
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint4_17Input = {
+  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
+  readonly files?: Endpoint4_17Request["payload"]["files"]
 }
-const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
+const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
  raw["session.revert.stage"]({
    params: { sessionID: input["sessionID"] },
    payload: { messageID: input["messageID"], files: input["files"] },
@@ -259,61 +277,61 @@ const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16I
    Effect.map((value) => value.data),
  )

-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
-const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
-  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
 type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
 const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
-  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+  raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
 const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+  raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
+const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
  raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
+const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
  raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
  )

-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-type Endpoint4_21Input = {
-  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
-  readonly key: Endpoint4_21Request["params"]["key"]
-  readonly value: Endpoint4_21Request["payload"]["value"]
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+type Endpoint4_22Input = {
+  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
+  readonly key: Endpoint4_22Request["params"]["key"]
+  readonly value: Endpoint4_22Request["payload"]["value"]
 }
-const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
  raw["session.instructions.entry.put"]({
    params: { sessionID: input["sessionID"], key: input["key"] },
    payload: { value: input["value"] },
  }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly key: Endpoint4_22Request["params"]["key"]
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint4_23Input = {
+  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
+  readonly key: Endpoint4_23Request["params"]["key"]
 }
-const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
  raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
    Effect.mapError(mapClientError),
  )

-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint4_23Input = {
-  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly after?: Endpoint4_23Request["query"]["after"]
-  readonly follow?: Endpoint4_23Request["query"]["follow"]
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_24Input = {
+  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
+  readonly after?: Endpoint4_24Request["query"]["after"]
+  readonly follow?: Endpoint4_24Request["query"]["follow"]
 }
-const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
+const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
  Stream.unwrap(
    raw["session.log"]({
      params: { sessionID: input["sessionID"] },
@@ -324,22 +342,22 @@ const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23I
    ),
  )

-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
-const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
-  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
 type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
 const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
+  raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
+const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
  raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))

-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint4_26Input = {
-  readonly sessionID: Endpoint4_26Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_26Request["params"]["messageID"]
+type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint4_27Input = {
+  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_27Request["params"]["messageID"]
 }
-const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
+const Endpoint4_27 = (raw: RawClient["server.session"]) => (input: Endpoint4_27Input) =>
  raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
    Effect.mapError(mapClientError),
    Effect.map((value) => value.data),
@@ -355,22 +373,23 @@ const adaptGroup4 = (raw: RawClient["server.session"]) => ({
  switchAgent: Endpoint4_6(raw),
  switchModel: Endpoint4_7(raw),
  rename: Endpoint4_8(raw),
-  prompt: Endpoint4_9(raw),
-  command: Endpoint4_10(raw),
-  skill: Endpoint4_11(raw),
-  synthetic: Endpoint4_12(raw),
-  shell: Endpoint4_13(raw),
-  compact: Endpoint4_14(raw),
-  wait: Endpoint4_15(raw),
-  revertStage: Endpoint4_16(raw),
-  revertClear: Endpoint4_17(raw),
-  revertCommit: Endpoint4_18(raw),
-  context: Endpoint4_19(raw),
-  instructions: { entry: { list: Endpoint4_20(raw), put: Endpoint4_21(raw), remove: Endpoint4_22(raw) } },
-  log: Endpoint4_23(raw),
-  interrupt: Endpoint4_24(raw),
-  background: Endpoint4_25(raw),
-  message: Endpoint4_26(raw),
+  move: Endpoint4_9(raw),
+  prompt: Endpoint4_10(raw),
+  command: Endpoint4_11(raw),
+  skill: Endpoint4_12(raw),
+  synthetic: Endpoint4_13(raw),
+  shell: Endpoint4_14(raw),
+  compact: Endpoint4_15(raw),
+  wait: Endpoint4_16(raw),
+  revertStage: Endpoint4_17(raw),
+  revertClear: Endpoint4_18(raw),
+  revertCommit: Endpoint4_19(raw),
+  context: Endpoint4_20(raw),
+  instructions: { entry: { list: Endpoint4_21(raw), put: Endpoint4_22(raw), remove: Endpoint4_23(raw) } },
+  log: Endpoint4_24(raw),
+  interrupt: Endpoint4_25(raw),
+  background: Endpoint4_26(raw),
+  message: Endpoint4_27(raw),
 })

 type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
@@ -529,7 +548,12 @@ 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))

-const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(raw) })
+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))
+
+const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(raw), catalog: Endpoint10_1(raw) })

 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
 type Endpoint11_0Input = {
@@ -1069,7 +1093,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"]),
@@ -23,6 +23,8 @@ import type {
  SessionSwitchModelOutput,
  SessionRenameInput,
  SessionRenameOutput,
+  SessionMoveInput,
+  SessionMoveOutput,
  SessionPromptInput,
  SessionPromptOutput,
  SessionCommandInput,
@@ -87,6 +89,8 @@ import type {
  IntegrationAttemptCancelOutput,
  ServerMcpListInput,
  ServerMcpListOutput,
+  ServerMcpCatalogInput,
+  ServerMcpCatalogOutput,
  CredentialUpdateInput,
  CredentialUpdateOutput,
  CredentialRemoveInput,
@@ -178,6 +182,8 @@ import type {
  VcsDiffInput,
  VcsDiffOutput,
  DebugLocationOutput,
+  DebugEvictLocationInput,
+  DebugEvictLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"

@@ -485,6 +491,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      move: (input: SessionMoveInput, requestOptions?: RequestOptions) =>
+        request<SessionMoveOutput>(
+          {
+            method: "POST",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
+            body: { destination: input["destination"], moveChanges: input["moveChanges"] },
+            successStatus: 204,
+            declaredStatuses: [404, 400, 401],
+            empty: true,
+          },
+          requestOptions,
+        ),
      prompt: (input: SessionPromptInput, requestOptions?: RequestOptions) =>
        request<{ readonly data: SessionPromptOutput }>(
          {
@@ -536,7 +554,12 @@ export function make(options: ClientOptions) {
          {
            method: "POST",
            path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
-            body: { text: input["text"], description: input["description"], metadata: input["metadata"] },
+            body: {
+              text: input["text"],
+              description: input["description"],
+              metadata: input["metadata"],
+              resume: input["resume"],
+            },
            successStatus: 204,
            declaredStatuses: [404, 400, 401],
            empty: true,
@@ -890,6 +913,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ),
+      catalog: (input?: ServerMcpCatalogInput, requestOptions?: RequestOptions) =>
+        request<ServerMcpCatalogOutput>(
+          {
+            method: "GET",
+            path: `/api/mcp/resource`,
+            query: { location: input?.["location"] },
+            successStatus: 200,
+            declaredStatuses: [401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
    },
    credential: {
      update: (input: CredentialUpdateInput, requestOptions?: RequestOptions) =>
@@ -1494,6 +1529,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,
+        ),
    },
  }
 }
@@ -526,6 +526,20 @@ export type SessionRenameInput = {

 export type SessionRenameOutput = void

+export type SessionMoveInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly destination: {
+    readonly destination: { readonly directory: string }
+    readonly moveChanges?: boolean | undefined
+  }["destination"]
+  readonly moveChanges?: {
+    readonly destination: { readonly directory: string }
+    readonly moveChanges?: boolean | undefined
+  }["moveChanges"]
+}
+
+export type SessionMoveOutput = void
+
 export type SessionPromptInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
  readonly id?: {
@@ -856,17 +870,26 @@ export type SessionSyntheticInput = {
    readonly text: string
    readonly description?: string | null
    readonly metadata?: { readonly [x: string]: JsonValue }
+    readonly resume?: boolean | null
  }["text"]
  readonly description?: {
    readonly text: string
    readonly description?: string | null
    readonly metadata?: { readonly [x: string]: JsonValue }
+    readonly resume?: boolean | null
  }["description"]
  readonly metadata?: {
    readonly text: string
    readonly description?: string | null
    readonly metadata?: { readonly [x: string]: JsonValue }
+    readonly resume?: boolean | null
  }["metadata"]
+  readonly resume?: {
+    readonly text: string
+    readonly description?: string | null
+    readonly metadata?: { readonly [x: string]: JsonValue }
+    readonly resume?: boolean | null
+  }["resume"]
 }

 export type SessionSyntheticOutput = void
@@ -2478,6 +2501,36 @@ export type ServerMcpListOutput = {
  }>
 }

+export type ServerMcpCatalogInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type ServerMcpCatalogOutput = {
+  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 CredentialUpdateInput = {
  readonly credentialID: { readonly credentialID: string }["credentialID"]
  readonly location?: {
@@ -5508,6 +5561,14 @@ 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
@@ -6130,3 +6191,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
@@ -50,6 +50,29 @@ test("exposes every standard HTTP API group", () => {
  expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })

+test("MCP resource catalog uses the public HTTP contract", async () => {
+  let request: Request | undefined
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input) => {
+      request = input instanceof Request ? input : new Request(input)
+      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 result = await client["server.mcp"].catalog({ location: { directory: "/tmp/project" } })
+
+  expect(result.data.resources[0]?.uri).toBe("docs://readme")
+  expect(request?.method).toBe("GET")
+  expect(request?.url).toBe("http://localhost:3000/api/mcp/resource?location%5Bdirectory%5D=%2Ftmp%2Fproject")
+})
+
 test("file.read returns binary content from the public HTTP contract", async () => {
  let request: Request | undefined
  const client = OpenCode.make({
@@ -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

@@ -130,6 +130,8 @@ type Result = Success | Failure
 interface Success {
  readonly ok: true
  readonly value: CodeMode.DataValue
+  readonly unhandledRejections?: ReadonlyArray<CodeMode.Diagnostic>
+  readonly unhandledRejectionsTruncated?: boolean
  readonly logs?: ReadonlyArray<string>
  readonly truncated?: boolean
  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
@@ -144,7 +146,7 @@ interface Failure {
 }
 ```

-`toolCalls` contains the names of calls admitted by the runtime in call order. It is retained on failure so hosts can audit partial execution without exposing inputs or host failures. `truncated` is present when the value or logs were cut to fit `maxOutputBytes` (see Execution Limits).
+`toolCalls` contains the names of calls admitted by the runtime in call order. It is retained on failure so hosts can audit partial execution without exposing inputs or host failures. A successful execution may also contain `unhandledRejections`: normalized failures from promises the program started but never observed. The program's returned value remains successful, matching JavaScript's separation between an async function's result and floating promise rejections. `unhandledRejectionsTruncated` marks omitted rejection details, while `truncated` marks any result, rejection, or log truncation caused by `maxOutputBytes` (see Execution Limits).

 ### Tool-call hooks

@@ -241,12 +243,12 @@ CodeMode executes a deliberately bounded JavaScript subset. It supports:
 - `if`, conditional expressions, `switch`, `for`, `for...of` (arrays, strings, Maps, Sets, including assignment-form destructuring such as `for ([key, value] of entries)`), `for...in` (own keys of plain objects, index strings of arrays, and namespace/tool names of `tools` references - anything else is an error suggesting `for...of` or `Object.keys`, rather than real JS's surprising behavior of indices for strings and zero iterations for Maps/Sets), `while`, and `do...while`.
 - Arrow functions and function declarations with closures, defaults, rest parameters, and destructuring.
 - Optional chaining, nullish coalescing, templates, spread (arrays, strings, Maps, Sets), and `try`/`catch`.
- Common array, string, number, `Object`, `Math`, and `JSON` operations. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
+- Common array, string, number, `Object`, `Math`, and `JSON` operations, including primitive-number `valueOf`, the standard non-finite `Number` constants, and host-backed `Math.random`. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
 - `Date` - `Date.now()`/`Date.parse()`/`Date.UTC()`, `new Date(...)`, the getter methods, and date arithmetic/comparison via the time value. Dates stringify as ISO (`toString` included, for determinism across host timezones).
 - Regular expressions - `/literals/` and `new RegExp(...)` with `test`/`exec` (stateful `lastIndex` for `g`), plus string `match`/`matchAll`/`replace`/`replaceAll`/`split`/`search` with patterns. Match results are arrays carrying `index` and named `groups` as own properties (`input` is omitted). `replace` and `replaceAll` accept function replacers with captures, offset, input, and named groups; callbacks run sequentially, may await tool calls, and have their results coerced to strings. Invalid patterns, invalid flags, and missing-`g` calls fail with catchable errors that say what was wrong and how to fix it (escaping hints, the exact `/pattern/g` to write). Patterns run on the host engine, so pathological backtracking is bounded only by the execution timeout.
 - `Map` and `Set` - construction from entries/arrays/strings, `get`/`set`/`add`/`has`/`delete`/`clear`/`size`/`forEach`, and `keys`/`values`/`entries` returning **arrays** (not iterators).
 - URL helpers - `URL` resolution and mutation, linked `URLSearchParams`, `URL.canParse`/`URL.parse`, URI and URI-component encoding/decoding, and query parameter construction, lookup, mutation, sorting, callbacks, and materialization. URLSearchParams iteration methods return arrays, matching the Map/Set convention.
- First-class promises - an un-awaited `tools.ns.tool(...)` is a promise value whose call starts immediately on a supervised fiber; `await` resolves it (awaiting a non-promise value is a no-op, and `return tools.ns.tool(...)` resolves like an async-function return). `Promise.all`, `Promise.allSettled`, and `Promise.race` accept any array mixing promises and plain values (built inline, beforehand, or via spread); `Promise.resolve`/`Promise.reject` construct settled promises. `Promise.allSettled` rejection reasons are the same plain `{ name?, message }` data a `catch` binding sees, and `Promise.race` interrupts its losing in-flight calls. At most 8 tool calls run concurrently. When a program completes, still-running un-awaited calls are awaited before the execution ends; a failure from a call that was never awaited surfaces as an unhandled-rejection diagnostic.
+- First-class promises - an un-awaited `tools.ns.tool(...)` is a promise value whose call starts immediately on an execution-owned fiber; `await` resolves it (awaiting a non-promise value is a no-op, and `return tools.ns.tool(...)` resolves like an async-function return). `Promise.all`, `Promise.allSettled`, and `Promise.race` accept any array mixing promises and plain values (built inline, beforehand, or via spread); `Promise.resolve`/`Promise.reject` construct settled promises. `Promise.allSettled` rejection reasons are the same plain `{ name?, message }` data a `catch` binding sees, and `Promise.race` leaves losing calls running. At most 8 tool calls run concurrently. Before successful completion, CodeMode awaits still-running promises without marking their rejections handled and returns every unobserved ordinary rejection in `Success.unhandledRejections`, in promise-creation order. A fatal program failure instead cancels outstanding work; timeout and host interruption do the same.
 - `throw value` and `throw new Error(message)` for explicit program failure. `Error` (and `TypeError`/`RangeError`/`SyntaxError`/`ReferenceError`/`EvalError`/`URIError`) are real constructors, callable with or without `new`; error values are plain `{ name, message }` data that additionally satisfy `instanceof Error` (a specific type matches itself and `Error`, as in JS). Every caught failure - thrown errors, interpreter runtime errors, and tool failures - is `instanceof Error` in a `catch` block; a thrown non-error value (`throw "text"`) is not, matching JS. Caught failures carry the `name` the equivalent real-JS failure would have - `JSON.parse` and invalid regex patterns produce a `SyntaxError` (satisfying `instanceof SyntaxError`), an unknown identifier a `ReferenceError`, assigning to a constant a `TypeError`, a bad `normalize` form a `RangeError`; failures with no specific analogue (including tool failures) are named `"Error"`. `instanceof` also recognizes `Date`, `RegExp`, `Map`, `Set`, `URL`, `URLSearchParams`, `Array`, `Object`, and `Promise`; any other right-hand side is a catchable error.

 Inside a program, standard-library values stay live everywhere: the internal data checkpoints (`Object.*` helpers, spread, coercion inputs) preserve the instances, so `Object.values({ d: date })[0].getTime()` and a spread copy of an object holding a Map keep working. Only at the host boundary (final result, tool arguments, `JSON.stringify`) do they serialize exactly as `JSON.stringify` would: Date and URL become strings (an invalid Date becomes `null`), while RegExp, Map, Set, and URLSearchParams become `{}`. Promise values never cross a data boundary: an un-awaited promise in a result or tool argument produces a diagnostic that says to await it, instead of serializing to `{}`.
@@ -263,7 +265,7 @@ The limits are exactly three knobs:
 | ---------------- | -------------------: | -------------------------------------------------------------------- |
 | `timeoutMs`      |    none - no timeout | Wall-clock execution time.                                           |
 | `maxToolCalls`   |     none - unlimited | Tool calls admitted during the execution.                            |
-| `maxOutputBytes` | none - no truncation | Model-facing output: the serialized result value plus captured logs. |
+| `maxOutputBytes` | none - no truncation | Retained payload: result value, unhandled rejections, and logs.       |

 No limit has a default, on purpose: execution budgets are host policy, not library policy - a host that wants a bound sets one; a host that can interrupt the execution fiber (as OpenCode does on user cancel) may set no timeout, and a host with its own tool-output truncation (as OpenCode has) may leave `maxOutputBytes` unset. A host with neither should set `maxOutputBytes`, or oversized results silently flood model context.

@@ -281,7 +283,9 @@ const runtime = CodeMode.make({

 Limits are safe integers. `timeoutMs` must be at least `1`; the others may be `0`. Invalid configuration throws a `RangeError` when `CodeMode.make` or `CodeMode.execute` is called. An explicitly `undefined` value is the same as leaving the limit unset.

-Exceeding a configured `maxOutputBytes` never fails the execution. An oversized result value is replaced by its truncated serialized text plus an explanatory marker, logs are kept from the start until the remaining budget is exhausted (with a final marker line noting the cut), and the result carries `truncated: true`.
+`maxOutputBytes` is a payload budget, not a strict byte cap on the final rendered tool message. It counts the serialized result value, retained rejection diagnostics, and retained log lines. Fixed truncation notices and framing added by a host when it renders the structured result are additional and may make the final message exceed the configured number.
+
+Exceeding a configured `maxOutputBytes` never fails the execution. An oversized result value is replaced by its truncated serialized text plus an explanatory marker, leading unhandled rejections and logs are kept within the remaining budget, omitted entries receive a summary marker, and the result carries `truncated: true`.

 When configured, the timeout interrupts in-flight tool Effects, including eagerly started calls the program has not awaited (their fibers are supervised by the execution). The interpreter yields cooperatively between steps, so the timeout also interrupts pure busy loops (`while (true) {}`) - no separate work budget exists. Tool implementations remain responsible for making their external operations interruptible or independently bounded.

@@ -62,13 +62,19 @@ path lookup, namespace browsing, deterministic ranking, and pagination.

 ### Tool execution

-Calling a tool starts its Effect eagerly on a supervised fiber. The returned sandbox promise is run-once and can be
-awaited directly or through the supported `Promise` combinators. At most eight tool calls execute concurrently.
-Unfinished calls are drained before successful program completion, and an unhandled call failure becomes a diagnostic.
+Every sandbox promise starts eagerly on a run-once fiber owned by the whole CodeMode execution, including tool calls,
+async functions, `Promise.all`, `Promise.allSettled`, `Promise.race`, `Promise.resolve`, and `Promise.reject`. Nested
+functions therefore cannot end the lifetime of work they started. Independent aggregate batches overlap, and rejection
+is observed at the eventual `await`. `Promise.race` uses native non-cancelling settlement semantics: its first result
+wins while losers continue. Before normal completion, CodeMode drains all active promises without marking them observed,
+then returns every unobserved ordinary rejection in `Success.unhandledRejections` while preserving the program value.
+A fatal program failure, timeout, or host interruption closes the execution promise scope and interrupts its active
+fibers instead. At most eight tool calls execute concurrently.

 The public execution-policy knobs are `timeoutMs`, `maxToolCalls`, and `maxOutputBytes`. The package supplies no
 defaults because budgets are host policy. The interpreter also enforces fixed internal boundaries for tool-call
-concurrency and data nesting depth.
+concurrency and data nesting depth. `maxOutputBytes` bounds retained payload bytes, not the complete rendered message;
+fixed truncation notices and host-added framing are intentionally outside the budget.

 ### Data, files, and failures

@@ -131,7 +137,7 @@ represent accurately rather than guessing semantics.
 | Treat schemas as the model-facing interface. | Signatures drive correct calls; Effect Schema also provides the runtime validation boundary, while JSON Schema supports adapter interoperability. |
 | Keep authority host-owned. | CodeMode can only confine programs to supplied tools. The host chooses those tools, and each tool enforces its own authorization and side-effect policy. |
 | Use progressive catalog disclosure plus search. | Large tool sets should not consume the prompt, but every namespace must remain discoverable and speculative search calls should remain valid. |
-| Start tool promises eagerly and supervise them. | This preserves normal call-time parallelism while giving each call run-once settlement and interruption safety. |
+| Own eager promises for the whole execution. | This preserves normal call-time parallelism and run-once settlement without tying promise lifetime to a transient async function. |
 | Keep files outside the sandbox value space. | Models should compose structured data without routing binary payloads through generated code or context. |
 | Treat `execute` as the model-facing invocation boundary. | Nested calls are implementation details of one orchestration program. Reusing the outer context and bounding only the final result preserves complete intermediate data without inventing durable child-call identities. |
 | Return expected failures as data. | Models need actionable diagnostics without exposing private host causes; host interruption and defects must still propagate correctly. |
@@ -158,7 +164,7 @@ current omissions to implement, not intentional product boundaries.
 - [ ] Add `Object.is` after runtime method and tool references have stable identity semantics.
 - [ ] Add deterministic modern collection conveniences where they improve orchestration: `Object.groupBy`, Set
      composition methods, and `Array.prototype.toSpliced`.
- [ ] Decide whether nondeterministic `Math.random` and iterable `Math.sumPrecise` belong in the runtime.
+- [ ] Decide whether iterable `Math.sumPrecise` belongs in the runtime.
 - [ ] Refine diagnostics so user throws, expected tool failures, unexpected host/tool defects, and genuine interpreter
      defects are distinguishable without leaking private causes.

@@ -17,7 +17,7 @@ export type ExecutionLimits = {
  readonly timeoutMs?: number
  /** Maximum number of tool calls admitted by the runtime. No default: absent means unlimited. */
  readonly maxToolCalls?: number
-  /** Maximum UTF-8 bytes of model-facing output. No default: absent means no truncation. */
+  /** Maximum UTF-8 bytes retained from output payloads. Fixed truncation notices and host formatting are additional. */
  readonly maxOutputBytes?: number
 }

@@ -92,6 +92,8 @@ const ToolCallSchema = Schema.Struct({ name: Schema.String })
 export const Success = Schema.Struct({
  ok: Schema.Literal(true),
  value: Schema.Json,
+  unhandledRejections: Schema.optionalKey(Schema.Array(Diagnostic)),
+  unhandledRejectionsTruncated: Schema.optionalKey(Schema.Boolean),
  logs: Schema.optionalKey(Schema.Array(Schema.String)),
  truncated: Schema.optionalKey(Schema.Boolean),
  toolCalls: Schema.Array(ToolCallSchema),
@@ -30,7 +30,6 @@ export type Binding = {

 export type StatementResult =
  | { kind: "none" }
-  | { kind: "value"; value: unknown }
  | { kind: "return"; value: unknown }
  | { kind: "break" }
  | { kind: "continue" }
@@ -1,5 +1,5 @@
 import { parse } from "acorn"
-import { Cause, Effect, Exit, Fiber, Semaphore } from "effect"
+import { Cause, Effect, Exit, Fiber, Scope, Semaphore } from "effect"
 import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript"
 import {
  copyIn,
@@ -219,7 +219,7 @@ const normalizeError = (error: unknown): Diagnostic => {
  }
 }

-// Shared by catch bindings, Promise.allSettled rejection reasons, and Promise.race losers.
+// Shared by catch bindings and Promise.allSettled rejection reasons.
 const caughtErrorValue = (thrown: unknown): unknown => {
  if (thrown instanceof ProgramThrow) return thrown.value
  if (thrown instanceof InterpreterRuntimeError) return createErrorValue(thrown.errorName, thrown.message)
@@ -530,17 +530,29 @@ const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): u
      if (args[0] instanceof SandboxURLSearchParams) {
        return Array.from(args[0].params.entries(), ([key, value]) => [key, value])
      }
-      const source = boundedData(args[0], "Array.from input")
+      const source = args[0]
+      if (source instanceof SandboxPromise) {
+        throw new InterpreterRuntimeError(
+          "Array.from received an un-awaited Promise; await it before creating the array.",
+          node,
+          "InvalidDataValue",
+        )
+      }
      if (typeof source === "string") return Array.from(source)
      if (Array.isArray(source)) return [...source]
      if (
        source !== null &&
        typeof source === "object" &&
+        (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
        typeof (source as { length?: unknown }).length === "number"
      ) {
        return Array.from(source as ArrayLike<unknown>)
      }
-      throw new InterpreterRuntimeError("Array.from expects an array, string, Map, Set, or array-like value.", node)
+      throw new InterpreterRuntimeError(
+        "Array.from expects an array, string, Map, Set, or array-like value.",
+        node,
+        "InvalidDataValue",
+      )
    }
    default:
      throw new InterpreterRuntimeError(`Array.${name} is not available in CodeMode.`, node)
@@ -599,6 +611,54 @@ const collectPatternNames = (pattern: AstNode, out: Array<string> = []): Array<s
  return out
 }

+// Promise work has execution lifetime, while observation only controls whether a settled
+// rejection is reported. Awaiting work during final draining must not conflate the two.
+class PromiseRuntime<R> {
+  private readonly active = new Set<SandboxPromise>()
+  private readonly ids = new WeakMap<SandboxPromise, number>()
+  private readonly observed = new WeakSet<SandboxPromise>()
+  private readonly failures = new Map<number, Diagnostic>()
+  private nextID = 0
+
+  constructor(private readonly scope: Scope.Scope) {}
+
+  create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<SandboxPromise, never, R> {
+    const id = this.nextID++
+    return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
+      const promise = new SandboxPromise(fiber)
+      this.active.add(promise)
+      this.ids.set(promise, id)
+      fiber.addObserver((exit) => {
+        this.active.delete(promise)
+        if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || this.observed.has(promise)) {
+          this.ids.delete(promise)
+          return
+        }
+        this.failures.set(id, normalizeError(Cause.squash(exit.cause)))
+      })
+      return promise
+    })
+  }
+
+  observe(promise: SandboxPromise): Effect.Effect<Exit.Exit<unknown, unknown>> {
+    this.observed.add(promise)
+    const id = this.ids.get(promise)
+    this.ids.delete(promise)
+    if (id !== undefined) this.failures.delete(id)
+    return Fiber.await(promise.fiber)
+  }
+
+  drain(): Effect.Effect<Array<Diagnostic>> {
+    const self = this
+    return Effect.gen(function* () {
+      while (self.active.size > 0) {
+        for (const promise of [...self.active]) yield* Fiber.await(promise.fiber)
+      }
+      return [...self.failures].sort(([left], [right]) => left - right).map(([, failure]) => failure)
+    })
+  }
+}
+
 class Interpreter<R> {
  private scopes: Array<Map<string, Binding>>
  private readonly invokeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
@@ -606,28 +666,24 @@ 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
-  // program completion drains these (like a runtime waiting on in-flight work at exit) and
-  // surfaces a never-awaited failure as an unhandled-rejection diagnostic.
-  private readonly pendingSettlements: Set<SandboxPromise>
+  private readonly promises: PromiseRuntime<R>

  constructor(
    invokeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>,
    toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>,
+    promises: PromiseRuntime<R>,
    logs: Array<string> = [],
-    shared?: { callPermits: Semaphore.Semaphore; pendingSettlements: Set<SandboxPromise> },
+    callPermits: Semaphore.Semaphore = Semaphore.makeUnsafe(TOOL_CALL_CONCURRENCY),
  ) {
    const globalScope = new Map<string, Binding>()
    this.scopes = [globalScope]
    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>()
+    this.callPermits = callPermits
+    this.promises = promises
    globalScope.set("tools", { mutable: false, value: new ToolReference([]) })
    globalScope.set("Promise", { mutable: false, value: new PromiseNamespace() })
    globalScope.set("undefined", { mutable: false, value: undefined })
@@ -671,13 +727,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,46 +743,18 @@ 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
      // without an explicit await, exactly as in JS.
      if (value instanceof SandboxPromise) value = yield* self.settlePromise(value)
-      yield* self.drainPendingSettlements()
      return value
    }).pipe(Effect.ensuring(Effect.sync(() => self.popScope())))
  }

-  // Awaits every fiber-backed promise the program abandoned (fire-and-forget tool calls), so
-  // their work completes before the execution ends - mirroring a JS runtime waiting on
-  // in-flight I/O at exit. A failure nobody could have handled becomes an unhandled-rejection
-  // diagnostic (interrupted calls, e.g. Promise.race losers, are ignored).
-  private drainPendingSettlements(): Effect.Effect<void, unknown, never> {
-    const self = this
-    return Effect.gen(function* () {
-      while (self.pendingSettlements.size > 0) {
-        const promise = self.pendingSettlements.values().next().value
-        if (promise === undefined) break
-        const exit = yield* self.observePromise(promise)
-        if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause)) continue
-        const failure = normalizeError(Cause.squash(exit.cause))
-        throw new InterpreterRuntimeError(
-          `Unhandled rejection from an un-awaited promise: ${failure.message}`,
-          undefined,
-          failure.kind,
-          ["Await promises so failures can be caught and handled."],
-        )
-      }
-    })
-  }
-
-  // Eagerly starts a tool call on a supervised child fiber (so the execution timeout and
-  // scope teardown interrupt it) gated by the concurrency semaphore, and wraps the fiber in a
+  // Eagerly starts a tool call in the execution's promise scope (so timeout and teardown
+  // interrupt it) gated by the concurrency semaphore, and wraps the fiber in a
  // first-class promise value. `startImmediately` makes the runtime admit the call - charging
  // the tool-call budget and firing onToolCallStart - at the call site, before any await.
  private createToolCallPromise(
@@ -735,52 +765,35 @@ class Interpreter<R> {
  }

  private createPromise(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<SandboxPromise, never, R> {
-    return Effect.map(Effect.forkChild(effect, { startImmediately: true }), (fiber) => {
-      const promise = new SandboxPromise(fiber)
-      this.pendingSettlements.add(promise)
-      return promise
-    })
+    return this.promises.create(effect)
  }

  // The promise's settlement as an Exit, marking it observed for unhandled-rejection tracking.
  // Fiber settlement is idempotent, so observing the same promise repeatedly (await twice,
  // Promise.all([p, p])) never re-runs the underlying call.
  private observePromise(promise: SandboxPromise): Effect.Effect<Exit.Exit<unknown, unknown>> {
-    this.pendingSettlements.delete(promise)
-    return promise.fiber !== undefined ? Fiber.await(promise.fiber) : Effect.exit(promise.immediate ?? Effect.void)
+    return this.promises.observe(promise)
  }

  // `await promise`: succeed with the fulfilled value or re-raise the failure so try/catch
  // observes it exactly like a synchronous throw at the await site.
  private settlePromise(promise: SandboxPromise, node?: AstNode): Effect.Effect<unknown, unknown, never> {
    const self = this
-    return Effect.flatMap(this.observePromise(promise), (exit) => self.unwrapPromiseExit(promise, exit, node))
+    return Effect.flatMap(this.observePromise(promise), (exit) => self.unwrapPromiseExit(exit, node))
  }

  private unwrapPromiseExit(
-    promise: SandboxPromise | undefined,
    exit: Exit.Exit<unknown, unknown>,
    node?: AstNode,
  ): Effect.Effect<unknown, unknown> {
    if (Exit.isSuccess(exit)) return Effect.succeed(exit.value)
-    // A call Promise.race interrupted after losing settles as a catchable program failure;
-    // any other interruption is execution teardown (timeout/host) and must keep propagating
-    // as interruption rather than becoming program-visible data.
-    if (promise?.interrupted === true && Cause.hasInterruptsOnly(exit.cause)) {
-      return Effect.fail(
-        new InterpreterRuntimeError(
-          "This tool call was interrupted because another value settled a Promise.race first.",
-          node,
-        ),
-      )
-    }
    return Effect.failCause(exit.cause)
  }

  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 +846,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 +937,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 +964,6 @@ class Interpreter<R> {
          return result
        }

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

      return { kind: "none" } satisfies StatementResult
@@ -987,9 +991,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 +1046,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 +1130,6 @@ class Interpreter<R> {
          return { kind: "none" }
        }

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

-        if (result.kind === "value") {
-          self.lastValue = result.value
-        }
-
        if (result.kind === "continue") {
          continue
        }
@@ -2033,6 +2022,9 @@ class Interpreter<R> {
        if (callable.namespace === "Object" && objectMethodsPreservingIdentity.has(callable.name)) {
          return invokeGlobalMethod(callable, args, node)
        }
+        if (callable.namespace === "Array" && (callable.name === "from" || callable.name === "of")) {
+          return invokeGlobalMethod(callable, args, node)
+        }
        return boundedData(invokeGlobalMethod(callable, args, node), `${callable.namespace}.${callable.name} result`)
      }
      if (callable instanceof CoercionFunction) {
@@ -2225,19 +2217,21 @@ class Interpreter<R> {
      // Promise.resolve of a promise is that promise (JS flattens); anything else is a
      // promise already fulfilled with the value.
      const value = args[0]
-      return Effect.succeed(
-        value instanceof SandboxPromise ? value : new SandboxPromise(undefined, Effect.succeed(value)),
-      )
+      return value instanceof SandboxPromise ? Effect.succeed(value) : this.createPromise(Effect.succeed(value))
    }
    if (ref.name === "reject") {
-      return Effect.sync(() => new SandboxPromise(undefined, Effect.fail(new ProgramThrow(args[0]))))
+      return this.createPromise(Effect.fail(new ProgramThrow(args[0])))
    }

    const items = Array.isArray(args[0]) ? args[0] : spreadItems(args[0])
    if (items === undefined) {
-      throw new InterpreterRuntimeError(
-        `Promise.${ref.name} expects an array of promises or plain values (e.g. Promise.${ref.name}(items.map((item) => tools.ns.tool(item)))).`,
-        node,
+      return this.createPromise(
+        Effect.fail(
+          new InterpreterRuntimeError(
+            `Promise.${ref.name} expects an array of promises or plain values (e.g. Promise.${ref.name}(items.map((item) => tools.ns.tool(item)))).`,
+            node,
+          ),
+        ),
      )
    }

@@ -2248,10 +2242,10 @@ class Interpreter<R> {
        // preserve input order when they all fulfill. Rejected calls keep draining siblings.
        const observations = items.map((item, index) =>
          item instanceof SandboxPromise
-            ? Effect.map(this.observePromise(item), (exit) => ({ index, item, exit }))
-            : Effect.succeed({ index, item: undefined, exit: Exit.succeed(item) }),
+            ? Effect.map(this.observePromise(item), (exit) => ({ index, exit }))
+            : Effect.succeed({ index, exit: Exit.succeed(item) }),
        )
-        return Effect.gen(function* () {
+        const aggregate = Effect.gen(function* () {
          const remaining = [...observations]
          const values: Array<unknown> = []
          values.length = items.length
@@ -2263,62 +2257,53 @@ class Interpreter<R> {
              values[winner.index] = winner.exit.value
              continue
            }
-            yield* self.createPromise(
-              Effect.asVoid(
-                Effect.forEach(
-                  items,
-                  (item) => (item instanceof SandboxPromise ? self.observePromise(item) : Effect.void),
-                  { concurrency: "unbounded" },
-                ),
-              ),
-            )
-            return yield* self.unwrapPromiseExit(winner.item, winner.exit, node)
+            return yield* self.unwrapPromiseExit(winner.exit, node)
          }
          return values
        })
+        return this.createPromise(aggregate)
      }
      case "allSettled": {
        const observations = items.map((item) =>
          item instanceof SandboxPromise
-            ? Effect.map(this.observePromise(item), (exit) => ({ promise: item as SandboxPromise | undefined, exit }))
-            : Effect.succeed({ promise: undefined as SandboxPromise | undefined, exit: Exit.succeed(item as unknown) }),
+            ? this.observePromise(item)
+            : Effect.succeed(Exit.succeed(item as unknown)),
        )
-        return Effect.gen(function* () {
-          const outcomes: Array<unknown> = []
-          for (const observation of observations) {
-            const { exit, promise } = yield* observation
-            if (Exit.isSuccess(exit)) {
-              outcomes.push(
-                Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }),
-              )
-              continue
-            }
-            const raceInterrupted = promise?.interrupted === true && Cause.hasInterruptsOnly(exit.cause)
-            if (Cause.hasInterruptsOnly(exit.cause) && !raceInterrupted) {
-              // Execution teardown (timeout/host interruption), not a program-level rejection.
-              return yield* Effect.failCause(exit.cause)
-            }
-            const thrown = raceInterrupted
-              ? new InterpreterRuntimeError(
-                  "This tool call was interrupted because another value settled a Promise.race first.",
-                  node,
+        return this.createPromise(
+          Effect.gen(function* () {
+            const outcomes: Array<unknown> = []
+            for (const observation of observations) {
+              const exit = yield* observation
+              if (Exit.isSuccess(exit)) {
+                outcomes.push(
+                  Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }),
                )
-              : Cause.squash(exit.cause)
-            outcomes.push(
-              Object.assign(Object.create(null) as SafeObject, {
-                status: "rejected",
-                reason: caughtErrorValue(thrown),
-              }),
-            )
-          }
-          return outcomes
-        })
+                continue
+              }
+              if (Cause.hasInterruptsOnly(exit.cause)) {
+                // Execution teardown (timeout/host interruption), not a program-level rejection.
+                return yield* Effect.failCause(exit.cause)
+              }
+              outcomes.push(
+                Object.assign(Object.create(null) as SafeObject, {
+                  status: "rejected",
+                  reason: caughtErrorValue(Cause.squash(exit.cause)),
+                }),
+              )
+            }
+            return outcomes
+          }),
+        )
      }
      case "race": {
        if (items.length === 0) {
-          throw new InterpreterRuntimeError(
-            "Promise.race([]) would never settle; provide at least one promise or value.",
-            node,
+          return this.createPromise(
+            Effect.fail(
+              new InterpreterRuntimeError(
+                "Promise.race([]) would never settle; provide at least one promise or value.",
+                node,
+              ),
+            ),
          )
        }
        const observations = items.map((item, index) =>
@@ -2326,31 +2311,20 @@ class Interpreter<R> {
            ? Effect.map(this.observePromise(item), (exit) => ({ index, exit }))
            : Effect.succeed({ index, exit: Exit.succeed(item as unknown) }),
        )
-        return Effect.gen(function* () {
-          // First settlement (fulfilled OR rejected) wins; the observations never fail, so
-          // racing them yields exactly that. Losing in-flight calls are then interrupted.
-          const winner = yield* Effect.raceAll(observations)
-          for (const [index, item] of items.entries()) {
-            if (index === winner.index || !(item instanceof SandboxPromise) || item.fiber === undefined) continue
-            item.interrupted = true
-            yield* Fiber.interrupt(item.fiber)
-          }
-          const winningItem = items[winner.index]
-          return yield* self.unwrapPromiseExit(
-            winningItem instanceof SandboxPromise ? winningItem : undefined,
-            winner.exit,
-            node,
-          )
-        })
+        return this.createPromise(
+          Effect.gen(function* () {
+            // First settlement (fulfilled OR rejected) wins; losing work remains owned by the
+            // execution scope and is drained before normal completion.
+            const winner = yield* Effect.raceAll(observations)
+            return yield* self.unwrapPromiseExit(winner.exit, node)
+          }),
+        )
      }
    }
  }

  private invokeFunction(fn: CodeModeFunction, args: Array<unknown>): Effect.Effect<unknown, unknown, R> {
-    const invocation = new Interpreter(this.invokeTool, this.toolKeys, this.logs, {
-      callPermits: this.callPermits,
-      pendingSettlements: this.pendingSettlements,
-    })
+    const invocation = new Interpreter(this.invokeTool, this.toolKeys, this.promises, this.logs, this.callPermits)
    invocation.scopes = [...fn.capturedScopes, new Map<string, Binding>()]
    const run = Effect.gen(function* () {
      // Seed every parameter name into the scope as a TDZ slot first, so a default that
@@ -2372,7 +2346,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)
@@ -3518,18 +3492,28 @@ export const executeWithLimits = <const Tools extends Record<string, unknown>>(
    })
  }

-  const operation = Effect.gen(function* () {
-    const program = parseProgram(options.code)
-    const interpreter = new Interpreter<Services<Tools>>(tools.invoke, tools.keys, logs)
-    const value = yield* interpreter.run(program)
-    const result = copyOut(copyIn(value, "Execution result"), true) as DataValue
-    return {
-      ok: true,
-      value: result,
-      ...logged(),
-      toolCalls: tools.calls,
-    } satisfies Result
-  }).pipe((program) => {
+  const operation = Effect.acquireUseRelease(
+    Scope.make("parallel"),
+    (scope) =>
+      Effect.gen(function* () {
+        const program = parseProgram(options.code)
+        const promises = new PromiseRuntime<Services<Tools>>(scope)
+        const interpreter = new Interpreter<Services<Tools>>(tools.invoke, tools.keys, promises, logs)
+        const value = yield* interpreter.run(program)
+        // Validate the result before draining so an invalid value is a fatal completion that
+        // closes the promise scope instead of waiting for unrelated work.
+        const result = copyOut(copyIn(value, "Execution result"), true) as DataValue
+        const unhandledRejections = yield* promises.drain()
+        return {
+          ok: true,
+          value: result,
+          ...(unhandledRejections.length > 0 ? { unhandledRejections } : {}),
+          ...logged(),
+          toolCalls: tools.calls,
+        } satisfies Result
+      }),
+    (scope, exit) => Scope.close(scope, exit),
+  ).pipe((program) => {
    const timeoutMs = limits.timeoutMs
    if (timeoutMs === undefined) return program
    return program.pipe(
@@ -3573,11 +3557,11 @@ const utf8Truncate = (value: string, maxBytes: number): string => {
 }

 /**
- * Bounds the model-facing output (serialized result value plus logs) to `maxOutputBytes`.
- * Oversized values are replaced by their truncated serialized text with an explanatory marker,
- * and logs are kept from the start until the remaining budget is exhausted. Truncation never
- * fails the execution; `truncated: true` marks affected results. Only runs when the host set
- * `maxOutputBytes` - with the limit absent, output passes through unbounded.
+ * Bounds retained payload bytes (serialized result value, rejection diagnostics, and logs) to
+ * `maxOutputBytes`. Fixed truncation notices are added outside that payload budget, as is any
+ * framing added when a host renders the structured result. Truncation never fails the execution;
+ * `truncated: true` marks affected results. Only runs when the host set `maxOutputBytes` - with
+ * the limit absent, output passes through unbounded.
 */
 const boundOutput = (result: Result, maxOutputBytes: number): Result => {
  let truncated = false
@@ -3597,9 +3581,23 @@ const boundOutput = (result: Result, maxOutputBytes: number): Result => {
    }
  }

+  const rejections = result.ok ? (result.unhandledRejections ?? []) : []
+  const keptRejections: Array<Diagnostic> = []
+  const rejectionBudget = Math.max(0, maxOutputBytes - valueBytes)
+  let rejectionBytes = 0
+  for (const rejection of rejections) {
+    const bytes = utf8ByteLength(JSON.stringify(rejection)) + 1
+    if (rejectionBytes + bytes > rejectionBudget) break
+    rejectionBytes += bytes
+    keptRejections.push(rejection)
+  }
+  if (keptRejections.length < rejections.length) {
+    truncated = true
+  }
+
  const logs = result.logs ?? []
  const kept: Array<string> = []
-  const logBudget = Math.max(0, maxOutputBytes - valueBytes)
+  const logBudget = Math.max(0, maxOutputBytes - valueBytes - rejectionBytes)
  let logBytes = 0
  for (const line of logs) {
    const lineBytes = utf8ByteLength(line) + 1
@@ -3613,8 +3611,19 @@ const boundOutput = (result: Result, maxOutputBytes: number): Result => {
  }

  if (!truncated) return result
+  const rejectionsPart = keptRejections.length > 0 ? { unhandledRejections: keptRejections } : {}
+  const rejectionsTruncatedPart =
+    keptRejections.length < rejections.length ? { unhandledRejectionsTruncated: true as const } : {}
  const logsPart = kept.length > 0 ? { logs: kept } : {}
  return result.ok
-    ? { ok: true, value, ...logsPart, truncated: true, toolCalls: result.toolCalls }
+    ? {
+        ok: true,
+        value,
+        ...rejectionsPart,
+        ...rejectionsTruncatedPart,
+        ...logsPart,
+        truncated: true,
+        toolCalls: result.toolCalls,
+      }
    : { ok: false, error: result.error, ...logsPart, truncated: true, toolCalls: result.toolCalls }
 }
@@ -1,6 +1,7 @@
 export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"])

 export const mathMethods = new Set([
+  "random",
  "max",
  "min",
  "abs",
@@ -40,6 +41,7 @@ export const mathMethods = new Set([

 export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNode): number => {
  if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
+  if (name === "random") return Math.random()
  const nums = args.map((arg) => {
    if (typeof arg !== "number") throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node)
    return arg
@@ -1,6 +1,15 @@
-export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString"])
+export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"])

-export const numberConstants = new Set(["MAX_SAFE_INTEGER", "MIN_SAFE_INTEGER", "MAX_VALUE", "MIN_VALUE", "EPSILON"])
+export const numberConstants = new Set([
+  "MAX_SAFE_INTEGER",
+  "MIN_SAFE_INTEGER",
+  "MAX_VALUE",
+  "MIN_VALUE",
+  "EPSILON",
+  "NaN",
+  "POSITIVE_INFINITY",
+  "NEGATIVE_INFINITY",
+])

 export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"])

@@ -32,6 +41,9 @@ export const invokeNumberMethod = (value: number, name: string, args: Array<unkn
      result = value.toString(radix)
      break
    }
+    case "valueOf":
+      result = value
+      break
    default:
      throw new InterpreterRuntimeError(`Number method '${name}' is not available in CodeMode.`, node)
  }
@@ -1,6 +1,6 @@
 import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
 import { isBlockedMember } from "../tool-runtime.js"
-import { isSandboxValue, SandboxMap, SandboxSet, SandboxURLSearchParams } from "../values.js"
+import { isSandboxValue, SandboxMap, SandboxPromise, SandboxSet, SandboxURLSearchParams } from "../values.js"
 import { boundedData, coerceToString } from "./value.js"

 export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "assign", "fromEntries"])
@@ -10,13 +10,23 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
  if (!objectStatics.has(name)) throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
  const requireObject = (): Record<string, unknown> => {
    const input = args[0]
-    const value = boundedData(args[0], `Object.${name} input`)
    if (Array.isArray(input)) return input as unknown as Record<string, unknown>
-    if (isSandboxValue(value)) return {}
-    if (value === null || typeof value !== "object") {
-      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node)
+    if (isSandboxValue(input)) return {}
+    if (input instanceof SandboxPromise) {
+      throw new InterpreterRuntimeError(
+        `Object.${name} received an un-awaited Promise; await it before inspecting the result.`,
+        node,
+        "InvalidDataValue",
+      )
    }
-    return value as Record<string, unknown>
+    if (input === null || typeof input !== "object") {
+      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue")
+    }
+    const prototype = Object.getPrototypeOf(input)
+    if (prototype !== null && prototype !== Object.prototype) {
+      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue")
+    }
+    return input as Record<string, unknown>
  }
  const guardedSet = (out: Record<string, unknown>, key: string, item: unknown): void => {
    if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available in CodeMode.`, node)
@@ -28,15 +38,8 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
    guardedSet(out, coerceToString(key), item)
  }
  switch (name) {
-    case "keys": {
-      const value = boundedData(args[0], "Object.keys input")
-      if (isSandboxValue(value)) return []
-      if (Array.isArray(value)) return Object.keys(value)
-      if (value === null || typeof value !== "object") {
-        throw new InterpreterRuntimeError("Object.keys expects a data object or array.", node)
-      }
-      return Object.keys(value)
-    }
+    case "keys":
+      return Object.keys(requireObject())
    case "values":
      return Object.values(requireObject())
    case "entries":
@@ -617,6 +617,7 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
    "",
    "Use common JavaScript data operations, functions, control flow, selected standard-library methods, and awaited tool calls. Built-ins include Date, RegExp, Map, Set, URL, URLSearchParams, and URI encoding helpers.",
    "Modules/imports, classes, generators, timers, fetch, eval, prototype access, unlisted methods, and promise chaining are unavailable. Use Code Mode tools for external operations. Use await with try/catch.",
+    "Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
    "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
  ]

@@ -1,11 +1,7 @@
-import type { Effect, Fiber } from "effect"
+import type { Fiber } from "effect"

 export class SandboxPromise {
-  interrupted = false
-  constructor(
-    readonly fiber: Fiber.Fiber<unknown, unknown> | undefined,
-    readonly immediate?: Effect.Effect<unknown, unknown>,
-  ) {}
+  constructor(readonly fiber: Fiber.Fiber<unknown, unknown>) {}
 }

 export class SandboxDate {
@@ -658,6 +658,9 @@ describe("CodeMode public contract", () => {
    expect(instructions).toContain("URL, URLSearchParams, and URI encoding helpers")
    expect(instructions).not.toContain("host globals")
    expect(instructions).toContain("Use Code Mode tools for external operations")
+    expect(instructions).toContain(
+      "Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
+    )
    expect(instructions).toContain(
      "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
    )
@@ -1081,6 +1084,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(
@@ -48,6 +48,13 @@ const failingTool = Tool.make({
  run: () => Effect.fail(toolError("Lookup refused")),
 })

+const interruptedTool = Tool.make({
+  description: "Interrupt this call",
+  input: Schema.Struct({}),
+  output: Schema.String,
+  run: () => Effect.interrupt,
+})
+
 const completedTool = (trace: Trace) =>
  Tool.make({
    description: "Return the number of completed sleepy calls",
@@ -63,7 +70,14 @@ const run = (
  const trace = options.trace ?? makeTrace()
  return Effect.runPromise(
    CodeMode.execute({
-      tools: { host: { sleepy: sleepyTool(trace), fail: failingTool, completed: completedTool(trace) } },
+      tools: {
+        host: {
+          sleepy: sleepyTool(trace),
+          fail: failingTool,
+          interrupt: interruptedTool,
+          completed: completedTool(trace),
+        },
+      },
      code,
      ...(options.limits ? { limits: options.limits } : {}),
    }),
@@ -174,8 +188,7 @@ describe("first-class promise values", () => {
  })

  test("an awaited failure is catchable exactly like a synchronous throw", async () => {
-    expect(
-      await value(`
+    const result = await run(`
      const p = tools.host.fail({})
      try {
        await p
@@ -183,8 +196,11 @@ describe("first-class promise values", () => {
      } catch (e) {
        return e.message
      }
-    `),
-    ).toBe("Lookup refused")
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("Lookup refused")
+    expect(result.unhandledRejections).toBeUndefined()
  })

  test("a fire-and-forget call completes before the execution ends", async () => {
@@ -201,30 +217,47 @@ describe("first-class promise values", () => {
    expect(trace.interrupted).toBe(0)
  })

-  test("a never-awaited failing call surfaces as an unhandled-rejection diagnostic", async () => {
-    const diagnostic = await error(`
+  test("a never-awaited failing call preserves the result and reports the rejection", async () => {
+    const result = await run(`
      tools.host.fail({})
      return "done"
    `)
-    expect(diagnostic.kind).toBe("ToolFailure")
-    expect(diagnostic.message).toContain("Unhandled rejection from an un-awaited promise")
-    expect(diagnostic.message).toContain("Lookup refused")
-    expect(diagnostic.suggestions?.join(" ")).toContain("Await promises")
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("done")
+    expect(result.unhandledRejections).toStrictEqual([{ kind: "ToolFailure", message: "Lookup refused" }])
+    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
  })

-  test("a never-awaited failing async function surfaces as an unhandled promise rejection", async () => {
-    const diagnostic = await error(`
+  test("a never-awaited failing async function is reported with a successful result", async () => {
+    const result = await run(`
      const fail = async () => { throw new Error("boom") }
      fail()
      return "done"
    `)
-    expect(diagnostic.kind).toBe("ExecutionFailure")
-    expect(diagnostic.message).toContain("Unhandled rejection from an un-awaited promise")
-    expect(diagnostic.message).toContain("boom")
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("done")
+    expect(result.unhandledRejections).toStrictEqual([{ kind: "ExecutionFailure", message: "Uncaught: boom" }])
  })

-  test("drains promises started by an async function after an await", async () => {
-    const diagnostic = await error(`
+  test("output truncation bounds unhandled rejection diagnostics", async () => {
+    const result = await run(
+      `
+        for (let i = 0; i < 100; i += 1) Promise.reject(new Error("x".repeat(1_000)))
+        return "done"
+      `,
+      { limits: { maxOutputBytes: 64 } },
+    )
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.truncated).toBe(true)
+    expect(result.unhandledRejections).toBeUndefined()
+    expect(result.unhandledRejectionsTruncated).toBe(true)
+  })
+
+  test("drains and reports promises started by an async function after an await", async () => {
+    const result = await run(`
      const run = async () => {
        await tools.host.sleepy({ id: 1 })
        tools.host.fail({})
@@ -232,8 +265,92 @@ describe("first-class promise values", () => {
      run()
      return "done"
    `)
-    expect(diagnostic.kind).toBe("ToolFailure")
-    expect(diagnostic.message).toContain("Lookup refused")
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("done")
+    expect(result.unhandledRejections).toStrictEqual([{ kind: "ToolFailure", message: "Lookup refused" }])
+  })
+
+  test("reports every unhandled rejection in promise creation order", async () => {
+    const result = await run(`
+      Promise.reject(new Error("first"))
+      tools.host.fail({})
+      Promise.reject(new Error("third"))
+      return "done"
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.unhandledRejections).toStrictEqual([
+      { kind: "ExecutionFailure", message: "Uncaught: first" },
+      { kind: "ToolFailure", message: "Lookup refused" },
+      { kind: "ExecutionFailure", message: "Uncaught: third" },
+    ])
+  })
+
+  test("orders an async function rejection before promises created inside its body", async () => {
+    const result = await run(`
+      const outer = async () => {
+        Promise.reject(new Error("inner"))
+        throw new Error("outer")
+      }
+      outer()
+      return "done"
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.unhandledRejections).toStrictEqual([
+      { kind: "ExecutionFailure", message: "Uncaught: outer" },
+      { kind: "ExecutionFailure", message: "Uncaught: inner" },
+    ])
+  })
+
+  test("un-awaited interruptions settle without becoming rejections", async () => {
+    const result = await run(`
+      tools.host.interrupt({})
+      Promise.all([tools.host.interrupt({})])
+      return "done"
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("done")
+    expect(result.unhandledRejections).toBeUndefined()
+  })
+
+  test("a fatal program error cancels outstanding work without reporting unhandled rejections", async () => {
+    const trace = makeTrace()
+    const result = await run(
+      `
+        tools.host.sleepy({ id: 1, ms: 1_000 })
+        throw new Error("boom")
+      `,
+      { trace },
+    )
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.error.message).toBe("Uncaught: boom")
+    expect("unhandledRejections" in result).toBe(false)
+    expect(trace.completed).toBe(0)
+    expect(trace.interrupted).toBe(1)
+  })
+
+  test("async-function promises remain owned by the execution after the function returns", async () => {
+    const trace = makeTrace()
+    expect(
+      await value(
+        `
+          const launch = async () => {
+            tools.host.sleepy({ id: 1, ms: 40 })
+            Promise.all([tools.host.sleepy({ id: 2, ms: 40 })])
+            return "returned"
+          }
+          return await launch()
+        `,
+        { trace },
+      ),
+    ).toBe("returned")
+    expect(trace.starts).toEqual([1, 2])
+    expect(trace.completed).toBe(2)
+    expect(trace.interrupted).toBe(0)
  })
 })

@@ -245,6 +362,28 @@ describe("promises at data boundaries", () => {
    expect(diagnostic.message).toContain("await tools.ns.tool(...)")
  })

+  test("collection helpers do not let un-awaited promises cross the result boundary", async () => {
+    const diagnostic = await error(`return Array.from([Promise.resolve(1)])`)
+    expect(diagnostic.kind).toBe("InvalidDataValue")
+    expect(diagnostic.message).toContain("un-awaited Promise")
+  })
+
+  test("invalid returned data cancels pending work before final draining", async () => {
+    const trace = makeTrace()
+    const result = await run(
+      `
+        const pending = tools.host.sleepy({ id: 1, ms: 60_000 })
+        return { pending }
+      `,
+      { trace, limits: { timeoutMs: 100 } },
+    )
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.error.kind).toBe("InvalidDataValue")
+    expect(trace.completed).toBe(0)
+    expect(trace.interrupted).toBe(1)
+  })
+
  test("passing an un-awaited promise as a tool argument is a clear diagnostic", async () => {
    const diagnostic = await error(`return await tools.host.sleepy({ id: tools.host.sleepy({ id: 1 }) })`)
    expect(diagnostic.kind).toBe("InvalidDataValue")
@@ -264,6 +403,59 @@ describe("promises at data boundaries", () => {
 })

 describe("Promise.all over arbitrary arrays", () => {
+  test("combinators return promises that can be assigned and awaited later", async () => {
+    expect(
+      await value(`
+        const all = Promise.all([Promise.resolve(1)])
+        const settled = Promise.allSettled([Promise.reject("no")])
+        const race = Promise.race([Promise.resolve(2)])
+        const promises = [all instanceof Promise, settled instanceof Promise, race instanceof Promise]
+        return [promises, await all, await settled, await race]
+      `),
+    ).toEqual([[true, true, true], [1], [{ status: "rejected", reason: "no" }], 2])
+  })
+
+  test("separately-created aggregate batches overlap before either is awaited", async () => {
+    const trace = makeTrace()
+    expect(
+      await value(
+        `
+          const first = Promise.all([tools.host.sleepy({ id: 1, ms: 40 })])
+          const second = Promise.all([tools.host.sleepy({ id: 2, ms: 40 })])
+          return [await first, await second]
+        `,
+        { trace },
+      ),
+    ).toEqual([[1], [2]])
+    expect(trace.starts).toEqual([1, 2])
+    expect(trace.maxActive).toBeGreaterThan(1)
+  })
+
+  test("an aggregate created before a try block rejects at its later await", async () => {
+    expect(
+      await value(`
+        const aggregate = Promise.all([tools.host.fail({})])
+        try {
+          await aggregate
+          return "no"
+        } catch (error) {
+          return error.message
+        }
+      `),
+    ).toBe("Lookup refused")
+  })
+
+  test("awaiting an aggregate repeatedly does not rerun its members", async () => {
+    const result = await run(`
+      const aggregate = Promise.all([tools.host.sleepy({ id: 7 })])
+      return [await aggregate, await aggregate]
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toEqual([[7], [7]])
+    expect(result.toolCalls).toStrictEqual([{ name: "host.sleepy" }])
+  })
+
  test("mixes promises and plain values, preserving order", async () => {
    expect(
      await value(`
@@ -334,16 +526,18 @@ describe("Promise.all over arbitrary arrays", () => {
  })

  test("rejects with the first failure, catchable in-program", async () => {
-    expect(
-      await value(`
+    const result = await run(`
      try {
        await Promise.all([tools.host.sleepy({ id: 1 }), tools.host.fail({})])
        return "no"
      } catch (e) {
        return e.message
      }
-    `),
-    ).toBe("Lookup refused")
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("Lookup refused")
+    expect(result.unhandledRejections).toBeUndefined()
  })

  test("rejects before an earlier slow promise fulfills", async () => {
@@ -368,6 +562,30 @@ describe("Promise.all over arbitrary arrays", () => {
    expect(trace.interrupted).toBe(0)
  })

+  test("drains a later sibling rejection after failing fast", async () => {
+    const trace = makeTrace()
+    expect(
+      await value(
+        `
+          const failLater = async () => {
+            await tools.host.sleepy({ id: 1, ms: 40 })
+            throw new Error("later")
+          }
+          const aggregate = Promise.all([Promise.reject(new Error("first")), failLater()])
+          try {
+            await aggregate
+            return "no"
+          } catch (error) {
+            return error.message
+          }
+        `,
+        { trace },
+      ),
+    ).toBe("first")
+    expect(trace.completed).toBe(1)
+    expect(trace.interrupted).toBe(0)
+  })
+
  test("a non-collection argument is a clear error", async () => {
    const diagnostic = await error(`return await Promise.all(42)`)
    expect(diagnostic.message).toContain("Promise.all expects an array")
@@ -407,50 +625,62 @@ describe("Promise.allSettled", () => {
      return settled.filter((s) => s.status === "rejected").length
    `)
    expect(result.ok).toBe(true)
-    if (result.ok) expect(result.value).toBe(2)
+    if (!result.ok) return
+    expect(result.value).toBe(2)
+    expect(result.unhandledRejections).toBeUndefined()
  })
 })

 describe("Promise.race", () => {
-  test("first settlement wins and losers are interrupted", async () => {
+  test("first settlement wins and a direct loser completes during final draining", async () => {
    const trace = makeTrace()
    const result = await value(
      `
        const fast = tools.host.sleepy({ id: 1, ms: 10 })
-        const slow = tools.host.sleepy({ id: 2, ms: 5000 })
+        const slow = tools.host.sleepy({ id: 2, ms: 40 })
        return await Promise.race([fast, slow])
      `,
      { trace },
    )
    expect(result).toBe(1)
-    expect(trace.interrupted).toBe(1)
-    expect(trace.completed).toBe(1)
+    expect(trace.completed).toBe(2)
+    expect(trace.interrupted).toBe(0)
  })

-  test("awaiting an interrupted loser afterwards is a catchable program failure", async () => {
+  test("a direct loser remains awaitable after the race settles", async () => {
    expect(
      await value(`
      const fast = tools.host.sleepy({ id: 1, ms: 10 })
-      const slow = tools.host.sleepy({ id: 2, ms: 5000 })
+      const slow = tools.host.sleepy({ id: 2, ms: 40 })
      const winner = await Promise.race([fast, slow])
-      try {
-        await slow
-        return "no"
-      } catch (e) {
-        return { winner, caught: e.message }
-      }
+      return { winner, loser: await slow }
    `),
-    ).toEqual({
-      winner: 1,
-      caught: "This tool call was interrupted because another value settled a Promise.race first.",
-    })
+    ).toEqual({ winner: 1, loser: 2 })
+  })
+
+  test("a nested aggregate loser and its members complete during final draining", async () => {
+    const trace = makeTrace()
+    expect(
+      await value(
+        `
+          const nested = Promise.all([
+            tools.host.sleepy({ id: 1, ms: 40 }),
+            tools.host.sleepy({ id: 2, ms: 40 }),
+          ])
+          return await Promise.race(["immediate", nested])
+        `,
+        { trace },
+      ),
+    ).toBe("immediate")
+    expect(trace.completed).toBe(2)
+    expect(trace.interrupted).toBe(0)
  })

  test("a rejection can win the race", async () => {
    expect(
      await value(`
      try {
-        await Promise.race([tools.host.fail({}), tools.host.sleepy({ id: 1, ms: 5000 })])
+        await Promise.race([tools.host.fail({}), tools.host.sleepy({ id: 1, ms: 40 })])
        return "no"
      } catch (e) {
        return e.message
@@ -462,9 +692,18 @@ describe("Promise.race", () => {
  test("a plain value wins over pending promises", async () => {
    const trace = makeTrace()
    expect(
-      await value(`return await Promise.race([tools.host.sleepy({ id: 1, ms: 5000 }), "immediate"])`, { trace }),
+      await value(`return await Promise.race([tools.host.sleepy({ id: 1, ms: 40 }), "immediate"])`, { trace }),
    ).toBe("immediate")
-    expect(trace.interrupted).toBe(1)
+    expect(trace.completed).toBe(1)
+    expect(trace.interrupted).toBe(0)
+  })
+
+  test("a rejected race loser is observed by the aggregate", async () => {
+    const result = await run(`return await Promise.race(["winner", tools.host.fail({})])`)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("winner")
+    expect(result.unhandledRejections).toBeUndefined()
  })

  test("an empty race is a clear error instead of hanging", async () => {
@@ -478,6 +717,9 @@ describe("Promise.resolve / Promise.reject", () => {
    expect(await value(`return await Promise.resolve(42)`)).toBe(42)
    expect(await value(`return await Promise.resolve(Promise.resolve("nested"))`)).toBe("nested")
    expect(await value(`return await Promise.resolve(tools.host.sleepy({ id: 3 }))`)).toBe(3)
+    expect(await value(`const promise = Promise.resolve(1); return [promise].includes(Promise.resolve(promise))`)).toBe(
+      true,
+    )
  })

  test("reject produces a promise whose await throws the reason", async () => {
@@ -492,6 +734,32 @@ describe("Promise.resolve / Promise.reject", () => {
    `),
    ).toBe("nope")
  })
+
+  test("a rejection observed after settlement is handled", async () => {
+    expect(
+      await value(`
+        const rejected = Promise.reject(new Error("handled"))
+        await tools.host.sleepy({ id: 1 })
+        try {
+          await rejected
+          return "no"
+        } catch (error) {
+          return error.message
+        }
+      `),
+    ).toBe("handled")
+  })
+
+  test("an abandoned rejected promise is reported as unhandled", async () => {
+    const result = await run(`
+      Promise.reject(new Error("abandoned"))
+      return "done"
+    `)
+    expect(result.ok).toBe(true)
+    if (!result.ok) return
+    expect(result.value).toBe("done")
+    expect(result.unhandledRejections).toStrictEqual([{ kind: "ExecutionFailure", message: "Uncaught: abandoned" }])
+  })
 })

 describe("timeout interruption of forked calls", () => {
@@ -525,6 +793,20 @@ describe("timeout interruption of forked calls", () => {
    expect(result.error.kind).toBe("TimeoutExceeded")
    expect(trace.interrupted).toBe(2)
  })
+
+  test("a non-settling race loser times out and is interrupted once", async () => {
+    const trace = makeTrace()
+    const result = await run(`return await Promise.race(["winner", tools.host.sleepy({ id: 1, ms: 60000 })])`, {
+      trace,
+      limits: { timeoutMs: 100 },
+    })
+    expect(result.ok).toBe(false)
+    if (result.ok) return
+    expect(result.error.kind).toBe("TimeoutExceeded")
+    expect(trace.starts).toEqual([1])
+    expect(trace.completed).toBe(0)
+    expect(trace.interrupted).toBe(1)
+  })
 })

 describe("unsupported promise surface", () => {
@@ -19,6 +19,28 @@ const error = async (code: string) => {
  return result.error
 }

+describe("Number and Math", () => {
+  test("Math.random returns a number in [0, 1)", async () => {
+    expect(await value(`const n = Math.random(); return typeof n === "number" && n >= 0 && n < 1`)).toBe(true)
+  })
+
+  test("Number exposes native non-finite constants", async () => {
+    expect(
+      await value(
+        `return [Number.isNaN(Number.NaN), Number.POSITIVE_INFINITY === Infinity, Number.NEGATIVE_INFINITY === -Infinity]`,
+      ),
+    ).toEqual([true, true, true])
+  })
+
+  test("Number valueOf returns its primitive receiver", async () => {
+    expect(await value(`return (42).valueOf()`)).toBe(42)
+  })
+
+  test("Number valueOf does not enable boxed numbers", async () => {
+    expect((await error(`return new Number(42)`)).kind).toBe("UnsupportedSyntax")
+  })
+})
+
 describe("Date", () => {
  test("Date.now() returns a number", async () => {
    expect(await value(`return typeof Date.now()`)).toBe("number")
@@ -751,6 +773,43 @@ describe("sandbox values at intra-sandbox checkpoints", () => {
    )
  })

+  test("Object.values/entries preserve nested object identity", async () => {
+    expect(
+      await value(`
+      const child = { selected: false }
+      const rows = { a: child }
+      Object.values(rows)[0].selected = true
+      return child.selected
+    `),
+    ).toBe(true)
+    expect(
+      await value(`
+      const child = { selected: false }
+      const rows = { a: child }
+      Object.entries(rows)[0][1].selected = true
+      return child.selected
+    `),
+    ).toBe(true)
+  })
+
+  test("Object enumeration preserves promises and callable references", async () => {
+    expect(
+      await value(`
+      const pending = Promise.resolve(1)
+      const source = { pending }
+      return [Object.keys(source), Object.hasOwn(source, "pending"), await Object.values(source)[0], await Object.entries(source)[0][1]]
+    `),
+    ).toEqual([["pending"], true, 1, 1])
+    expect(await value(`return Object.values({ max: Math.max })[0](1, 2)`)).toBe(2)
+  })
+
+  test("Object enumeration rejects invalid receivers and gives promises an await hint", async () => {
+    const diagnostic = await error(`return Object.keys(Promise.resolve({ a: 1 }))`)
+    expect(diagnostic.kind).toBe("InvalidDataValue")
+    expect(diagnostic.message).toContain("await")
+    expect((await error(`return Object.keys(Math)`)).kind).toBe("InvalidDataValue")
+  })
+
  test("Object.assign keeps Maps usable", async () => {
    expect(await value(`const merged = Object.assign({}, { m: new Map([["a", 1]]) }); return merged.m.get("a")`)).toBe(
      1,
@@ -773,6 +832,53 @@ describe("sandbox values at intra-sandbox checkpoints", () => {
    expect(await value(`return Array.from([new Date(5)])[0].getTime()`)).toBe(5)
  })

+  test("Array.from and Array.of preserve nested object identity", async () => {
+    expect(
+      await value(`
+      const child = { selected: false }
+      Array.from([child])[0].selected = true
+      return child.selected
+    `),
+    ).toBe(true)
+    expect(
+      await value(`
+      const child = { selected: false }
+      Array.of(child)[0].selected = true
+      return child.selected
+    `),
+    ).toBe(true)
+  })
+
+  test("Array.from and Array.of preserve promises and callable references", async () => {
+    expect(
+      await value(`
+      const pending = Promise.resolve(1)
+      return [await Array.from([pending])[0], await Array.of(pending)[0]]
+    `),
+    ).toEqual([1, 1])
+    expect(await value(`return [Array.from([Math.max])[0](1, 2), Array.of(Math.max)[0](3, 4)]`)).toEqual([2, 4])
+  })
+
+  test("Array.from preserves identity across supported collection shapes", async () => {
+    expect(
+      await value(`
+      const child = { selected: false }
+      const fromArrayLike = Array.from({ 0: child, length: 1 })
+      const fromMap = Array.from(new Map([["child", child]]))
+      const fromSet = Array.from(new Set([child]))
+      fromArrayLike[0].selected = true
+      return [fromMap[0][1] === child, fromSet[0] === child, child.selected]
+    `),
+    ).toEqual([true, true, true])
+  })
+
+  test("Array.from rejects invalid receivers and gives promises an await hint", async () => {
+    const diagnostic = await error(`return Array.from(Promise.resolve([1]))`)
+    expect(diagnostic.kind).toBe("InvalidDataValue")
+    expect(diagnostic.message).toContain("await")
+    expect((await error(`return Array.from(() => 1)`)).kind).toBe("InvalidDataValue")
+  })
+
  test("regexes stay callable through Object.values", async () => {
    expect(await value(`return Object.values({ r: /ab+/ })[0].test("abb")`)).toBe(true)
  })
@@ -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)),
+      }),
    ),
  )
 }
@@ -3,7 +3,7 @@ export * as MCPClient from "./client"
 import path from "node:path"
 import { execFile } from "node:child_process"
 import { pathToFileURL } from "node:url"
-import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
 import { UnauthorizedError, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
@@ -21,6 +21,7 @@ import {
  ListToolsResultSchema,
  PromptListChangedNotificationSchema,
  PromptSchema,
+  ResourceListChangedNotificationSchema,
  type LoggingMessageNotification,
  LoggingMessageNotificationSchema,
  ToolListChangedNotificationSchema,
@@ -68,11 +69,13 @@ 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 {
@@ -84,6 +87,28 @@ 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 }
@@ -124,6 +149,12 @@ 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>
  /** Invokes a prompt on the server. Interruption aborts the in-flight request. */
  readonly prompt: (input: {
    readonly name: string
@@ -141,6 +172,8 @@ 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. */
+  readonly onResourcesChanged: (callback: () => void) => void
 }

 /** Connects an MCP server; closing the calling scope tears down the transport and any spawned process. */
@@ -168,7 +201,8 @@ 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,
@@ -202,10 +236,7 @@ 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
@@ -257,7 +288,9 @@ 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,
@@ -269,6 +302,74 @@ 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 },
+            ),
+          }
+        }),
      prompt: (input) =>
        Effect.tryPromise({
          try: (signal) =>
@@ -328,13 +429,14 @@ export const connect = Effect.fnUntraced(function* (
        if (!client.getServerCapabilities()?.prompts?.listChanged) return
        client.setNotificationHandler(PromptListChangedNotificationSchema, async () => callback())
      },
+      onResourcesChanged: (callback) => {
+        if (!client.getServerCapabilities()?.resources?.listChanged) return
+        client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => 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,48 +83,16 @@ export class PromptResult extends Schema.Class<PromptResult>("MCP.PromptResult")
  messages: Schema.Array(PromptMessage),
 }) {}

-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 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 NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("MCP.NotFoundError", {
  server: ServerName,
@@ -415,6 +383,24 @@ 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 refreshTools = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
      connection.tools().pipe(
        Effect.map((defs) => {
@@ -443,6 +429,7 @@ export const layer = Layer.effect(
        entry.prompts = undefined
        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))
      })
@@ -458,6 +445,10 @@ export const layer = Layer.effect(
      connection.onPromptsChanged(() => {
        fork(refreshPrompts(name, entry, connection).pipe(Effect.ignore))
      })
+      connection.onResourcesChanged(() => {
+        if (entry.client !== connection) return
+        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
+      })
    }

    const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
@@ -501,6 +492,7 @@ 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
@@ -557,11 +549,6 @@ 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))
@@ -637,11 +624,54 @@ export const layer = Layer.effect(
      }),
      resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
        yield* whenAllReady
-        return new ResourceCatalog({ resources: [], templates: [] })
+        const catalogs = yield* Effect.forEach(
+          Array.from(runtime),
+          ([name, entry]) => {
+            if (!entry.client) return Effect.succeed({ resources: [], templates: [] })
+            return Effect.all(
+              {
+                resources: entry.client.resources().pipe(Effect.catch(() => Effect.succeed([]))),
+                templates: entry.client.resourceTemplates().pipe(Effect.catch(() => Effect.succeed([]))),
+              },
+              { concurrency: "unbounded" },
+            ).pipe(
+              Effect.map((catalog) => ({
+                resources: catalog.resources.map((def) => toResource(name, def)),
+                templates: catalog.templates.map((def) => toResourceTemplate(name, def)),
+              })),
+            )
+          },
+          { concurrency: "unbounded" },
+        )
+        return ResourceCatalog.make({
+          resources: catalogs
+            .flatMap((catalog) => catalog.resources)
+            .toSorted(
+              (a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name) || a.uri.localeCompare(b.uri),
+            ),
+          templates: catalogs
+            .flatMap((catalog) => catalog.templates)
+            .toSorted(
+              (a, b) =>
+                a.server.localeCompare(b.server) ||
+                a.name.localeCompare(b.name) ||
+                a.uriTemplate.localeCompare(b.uriTemplate),
+            ),
+        })
      }),
      readResource: Effect.fn("MCP.readResource")(function* (input) {
-        yield* gate(input.server)
-        return undefined
+        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,
+        })
      }),
    })
  }),
@@ -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] })
@@ -243,6 +243,7 @@ export interface Interface {
    text: string
    description?: string
    metadata?: Record<string, unknown>
+    resume?: boolean
  }) => Effect.Effect<void, NotFoundError>
  readonly revert: {
    readonly stage: (input: {
@@ -682,6 +683,7 @@ const layer = Layer.effect(
          description: input.description,
          metadata: input.metadata,
        })
+        if (input.resume === false) return
        yield* execution
          .resume(input.sessionID)
          .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
@@ -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
@@ -176,9 +176,15 @@ function formatResult(result: CodeMode.Result) {
    : [result.error.message, ...(result.error.suggestions ?? []).filter((hint) => !result.error.message.includes(hint))]
        .join("\n")
        .trim()
-  if (!result.logs || result.logs.length === 0) return output
-  const logs = `Logs:\n${result.logs.join("\n")}`
-  return output === "" ? logs : `${output}\n\n${logs}`
+  const rejections =
+    result.ok && ((result.unhandledRejections?.length ?? 0) > 0 || result.unhandledRejectionsTruncated)
+      ? `Unhandled promise rejections:\n${[
+          ...(result.unhandledRejections ?? []).map((item) => `- [${item.kind}] ${item.message}`),
+          ...(result.unhandledRejectionsTruncated ? ["- Additional rejections omitted by the output limit."] : []),
+        ].join("\n")}\n\nAwait or explicitly settle all started promises.`
+      : undefined
+  const logs = result.logs && result.logs.length > 0 ? `Logs:\n${result.logs.join("\n")}` : undefined
+  return [output, rejections, logs].filter((part) => part !== undefined && part !== "").join("\n\n")
 }

 function formatValue(value: CodeMode.DataValue) {
@@ -4,16 +4,27 @@ 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: {}, tools: {} } })
+const server = new Server(
+  { name: "timeout", version: "1.0.0" },
+  { capabilities: { prompts: {}, resources: {}, 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: [] }
@@ -22,5 +33,9 @@ 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,15 +14,12 @@ export const emptyMcpLayer = Layer.succeed(
    instructions: () => Effect.succeed([]),
    prompts: () => Effect.succeed([]),
    prompt: () => Effect.succeed(undefined),
-    resourceCatalog: () => Effect.succeed(new MCP.ResourceCatalog({ resources: [], templates: [] })),
+    resourceCatalog: () => Effect.succeed(MCP.ResourceCatalog.make({ 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,26 +3,165 @@ 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 { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js"
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} 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, Fiber, Layer, Stream } from "effect"
+import { Deferred, Effect, Exit, 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; 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,
+      }
+      const protocol = new Server(
+        { name: "mcp-resources", version: "1.0.0" },
+        {
+          capabilities: {
+            tools: {},
+            ...(input.resources === false ? {} : { resources: { listChanged: input.listChanged } }),
+          },
+        },
+      )
+      protocol.setRequestHandler(ListToolsRequestSchema, () => Promise.resolve({ tools: [] }))
+      if (input.resources !== false) {
+        protocol.setRequestHandler(ListResourcesRequestSchema, (request) => {
+          state.resourceLists += 1
+          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 }))
+      }
+      const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        enableJsonResponse: true,
+      })
+      await protocol.connect(transport)
+      const http = Bun.serve({
+        port: 0,
+        fetch: (request) => transport.handleRequest(request),
+      })
+      return {
+        state,
+        url: http.url.toString(),
+        sendResourceListChanged: () => protocol.sendResourceListChanged(),
+        close: async () => {
+          await protocol.close().catch(() => {})
+          await http.stop(true)
+        },
+      }
+    }),
+    (server) => Effect.promise(server.close),
+  )
+}
+
+function resourceMcpLayer(url: string) {
+  const directory = AbsolutePath.make(import.meta.dir)
+  const unusedIntegration = () => Effect.die("unused integration service")
+  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, data) =>
+            Effect.succeed({
+              id: EventV2.ID.create(),
+              type: definition.type,
+              data,
+            } as EventV2.Payload<typeof definition>),
+        }),
+        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([
@@ -241,6 +380,163 @@ 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 reports MCP resource changes", 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("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("loads and reads MCP resources", async () => {
+  await Effect.runPromise(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const server = yield* resourceServer()
+        server.state.resources = [{ name: "Readme", uri: "docs://readme" }]
+        server.state.templates = [{ name: "File", uriTemplate: "docs://{path}" }]
+
+        yield* Effect.gen(function* () {
+          const service = yield* MCP.Service
+          expect(yield* service.resourceCatalog()).toEqual({
+            resources: [
+              {
+                server: "resources",
+                name: "Readme",
+                uri: "docs://readme",
+                description: undefined,
+                mimeType: undefined,
+              },
+            ],
+            templates: [
+              {
+                server: "resources",
+                name: "File",
+                uriTemplate: "docs://{path}",
+                description: undefined,
+                mimeType: undefined,
+              },
+            ],
+          })
+
+          server.state.resources = [{ name: "Guide", uri: "docs://guide" }]
+          expect((yield* service.resourceCatalog()).resources.map((resource) => resource.uri)).toEqual(["docs://guide"])
+          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)))
+      }),
+    ),
+  )
+})
+
 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",
@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test"
+import { ExecuteTool } from "@opencode-ai/core/tool/execute"
+import { Tool } from "@opencode-ai/core/tool/tool"
+import { Agent } from "@opencode-ai/schema/agent"
+import { Session } from "@opencode-ai/schema/session"
+import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { Effect, Schema } from "effect"
+
+test("execute preserves successful results with visible unhandled rejections", async () => {
+  const child = Tool.make({
+    description: "Always fail",
+    input: Schema.Struct({}),
+    output: Schema.String,
+    execute: () => Effect.fail(new Tool.Failure({ message: "Lookup refused" })),
+  })
+  const registration: ExecuteTool.Registration = { identity: {}, tool: child, name: "fail" }
+  const execute = ExecuteTool.create({
+    registrations: new Map([["fail", registration]]),
+    current: () => registration,
+  })
+  const result = await Effect.runPromise(
+    Tool.settle(
+      execute,
+      {
+        type: "tool-call",
+        id: "call_execute",
+        name: "execute",
+        input: { code: `tools.fail({}); return "done"` },
+      },
+      {
+        sessionID: Session.ID.make("ses_execute"),
+        agent: Agent.ID.make("build"),
+        assistantMessageID: SessionMessage.ID.make("msg_execute"),
+        toolCallID: "call_execute",
+      },
+    ),
+  )
+
+  expect(result.structured).toEqual({ toolCalls: [{ tool: "fail", status: "error" }] })
+  expect(result.content).toEqual([
+    {
+      type: "text",
+      text: [
+        "done",
+        "",
+        "Unhandled promise rejections:",
+        "- [ToolFailure] Lookup refused",
+        "",
+        "Await or explicitly settle all started promises.",
+      ].join("\n"),
+    },
+  ])
+})
@@ -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)",
@@ -475,6 +475,7 @@ export type TuiHostSlotMap = {
  }
  sidebar_footer: {
    session_id: string
+    directory: string
  }
 }

@@ -61,6 +61,7 @@ export const groupNames = {
 } as const

 export const endpointNames = {
+  "debug.location.evict": "evictLocation",
  "session.messages": "list",
  "integration.connect.key": "connectKey",
  "integration.connect.oauth": "connectOauth",
@@ -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" }))
@@ -19,4 +19,18 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
        }),
      ),
  )
-  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server status routes." }))
+  .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.",
+        }),
+      ),
+  )
+  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server and resource routes." }))
@@ -269,6 +269,25 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
          }),
        ),
    )
+    .add(
+      HttpApiEndpoint.post("session.move", "/api/session/:sessionID/move", {
+        params: { sessionID: Session.ID },
+        payload: Schema.Struct({
+          destination: Schema.Struct({ directory: AbsolutePath }),
+          moveChanges: Schema.Boolean.pipe(Schema.optional),
+        }),
+        success: HttpApiSchema.NoContent,
+        error: [SessionNotFoundError, InvalidRequestError],
+      })
+        .middleware(sessionLocationMiddleware)
+        .annotateMerge(
+          OpenApi.annotations({
+            identifier: "v2.session.move",
+            summary: "Move session",
+            description: "Move a session to another project directory, optionally transferring local changes.",
+          }),
+        ),
+    )
    .add(
      HttpApiEndpoint.post("session.prompt", "/api/session/:sessionID/prompt", {
        params: { sessionID: Session.ID },
@@ -344,6 +363,7 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
          text: Schema.String,
          description: Schema.String.pipe(Schema.optional),
          metadata: SessionMessage.Synthetic.fields.metadata,
+          resume: Schema.Boolean.pipe(Schema.optional),
        }),
        success: HttpApiSchema.NoContent,
        error: SessionNotFoundError,
@@ -4,5 +4,6 @@ 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,6 +80,7 @@ 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,6 +9,7 @@ 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,6 +10,13 @@ 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: {
@@ -27,4 +34,4 @@ export const StatusChanged = Event.ephemeral({
  },
 })

-export const Definitions = Event.inventory(ToolsChanged, StatusChanged)
+export const Definitions = Event.inventory(ToolsChanged, ResourcesChanged, StatusChanged)
@@ -25,14 +25,9 @@ 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({
@@ -42,3 +37,50 @@ 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,6 +2,7 @@ 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"
@@ -51,6 +52,11 @@ 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,
@@ -51,6 +51,7 @@ describe("public event manifest", () => {
    expect(EventManifest.Latest.get("agent.updated")).toBe(Agent.Event.Updated)
    expect(EventManifest.Latest.get("plugin.updated")).toBe(Plugin.Event.Updated)
    expect(EventManifest.Server.get("mcp.status.changed")).toBe(McpEvent.StatusChanged)
+    expect(EventManifest.Server.get("mcp.resources.changed")).toBe(McpEvent.ResourcesChanged)
    expect(EventManifest.Server.get("session.deleted")).toBe(SessionEvent.Deleted)
    expect(EventManifest.Server.has("mcp.tools.changed")).toBe(false)
    expect(Agent.Event.Updated.durable).toBeUndefined()
@@ -76,7 +77,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.StatusChanged])
+    expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.ResourcesChanged, 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])
@@ -0,0 +1,37 @@
+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" },
+      ],
+    })
+  })
+})
@@ -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,
@@ -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))
+      }),
+    ),
 )
@@ -6,20 +6,28 @@ 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())
+        }),
+      )
  }),
 )
@@ -1,5 +1,6 @@
 import { SessionV2 } from "@opencode-ai/core/session"
 import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
+import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
 import { Api } from "../api"
@@ -8,8 +9,8 @@ import {
  ConflictError,
  CommandEvaluationError,
  CommandNotFoundError,
-  InvalidCursorError,
  InvalidRequestError,
+  InvalidCursorError,
  MessageNotFoundError,
  ServiceUnavailableError,
  SessionBusyError,
@@ -24,6 +25,7 @@ const DefaultSessionsLimit = 50
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
  Effect.gen(function* () {
    const session = yield* SessionV2.Service
+    const moveSession = yield* MoveSession.Service

    return handlers
      .handle(
@@ -201,6 +203,43 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          return HttpApiSchema.NoContent.make()
        }),
      )
+      .handle(
+        "session.move",
+        Effect.fn(function* (ctx) {
+          yield* moveSession.moveSession({
+            sessionID: ctx.params.sessionID,
+            destination: ctx.payload.destination,
+            moveChanges: ctx.payload.moveChanges,
+          }).pipe(
+            Effect.catchTag("Session.NotFoundError", (error) =>
+              Effect.fail(
+                new SessionNotFoundError({
+                  sessionID: error.sessionID,
+                  message: `Session not found: ${error.sessionID}`,
+                }),
+              ),
+            ),
+            Effect.catchTag("MoveSession.DestinationProjectMismatchError", () =>
+              Effect.fail(new InvalidRequestError({ message: "Destination directory belongs to another project" })),
+            ),
+            Effect.catchTag("MoveSession.ApplyChangesError", () =>
+              Effect.fail(
+                new InvalidRequestError({
+                  message:
+                    "Unable to apply your changes in the destination directory. The files may conflict with existing changes.",
+                }),
+              ),
+            ),
+            Effect.catchTag("MoveSession.CaptureChangesError", (error) =>
+              Effect.fail(new InvalidRequestError({ message: error.message })),
+            ),
+            Effect.catchTag("MoveSession.ResetSourceChangesError", (error) =>
+              Effect.fail(new InvalidRequestError({ message: error.message })),
+            ),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
      .handle(
        "session.prompt",
        Effect.fn(function* (ctx) {
@@ -329,6 +368,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
              text: ctx.payload.text,
              description: ctx.payload.description,
              metadata: ctx.payload.metadata,
+              resume: ctx.payload.resume,
            })
            .pipe(
              Effect.catchTag("Session.NotFoundError", (error) =>
@@ -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()))),
@@ -8,6 +8,7 @@ import { Observability } from "@opencode-ai/core/observability"
 import { Credential } from "@opencode-ai/core/credential"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { PtyTicket } from "@opencode-ai/core/pty/ticket"
+import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
 import { Project } from "@opencode-ai/core/project"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
@@ -19,7 +20,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"
@@ -37,9 +38,11 @@ const applicationServices = LayerNode.group([
  httpClient,
  ToolOutputStore.cleanupNode,
  Job.node,
+  MoveSession.node,
  Project.node,
  SessionV2.node,
  PluginRuntime.providerNode,
+  SdkPlugins.node,
  PermissionSaved.node,
  PtyTicket.node,
  Credential.node,
@@ -55,26 +58,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 +84,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 +115,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"
@@ -19,8 +19,9 @@ import { Spinner } from "./spinner"
 import { DialogWorkspaceFileChanges } from "./dialog-workspace-file-changes"
 import type { ProjectDirectoriesOutput } from "@opencode-ai/client/promise"
 import { useRoute } from "../context/route"
+import { DialogProjectCopyName } from "./dialog-project-copy-name"

-export type MoveSessionSelection = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new" }
+export type MoveSessionSelection = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new"; name: string }
 type ProjectDirectory = ProjectDirectoriesOutput[number]

 type DialogMoveSessionProps = {
@@ -291,6 +292,12 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
    if (await removedCurrent(deletingCurrent)) return
  }

+  async function create() {
+    const name = await DialogProjectCopyName.show(dialog)
+    if (name === null) return
+    props.onSelect({ type: "new", name })
+  }
+
  const fullHeight = createMemo(() =>
    Math.max(8, Math.min(16, dimensions().height - Math.floor(dimensions().height / 4) - 2)),
  )
@@ -334,7 +341,7 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
                {
                  command: "dialog.move_session.new",
                  title: "new",
-                  onTrigger: () => props.onSelect({ type: "new" }),
+                  onTrigger: () => void create(),
                },
                {
                  command: "dialog.move_session.delete",
@@ -0,0 +1,95 @@
+import { InputRenderable, TextAttributes } from "@opentui/core"
+import { Slug } from "@opencode-ai/core/util/slug"
+import { createSignal, onMount } from "solid-js"
+import { useTuiConfig } from "../config"
+import { useTheme } from "../context/theme"
+import { useBindings, useCommandShortcut } from "../keymap"
+import { useDialog, type DialogContext } from "../ui/dialog"
+
+export function DialogProjectCopyName(props: { onConfirm: (name: string) => void }) {
+  const dialog = useDialog()
+  const { theme } = useTheme()
+  const tuiConfig = useTuiConfig()
+  const generateShortcut = useCommandShortcut("dialog.project_copy.generate")
+  const [inputTarget, setInputTarget] = createSignal<InputRenderable>()
+  let input: InputRenderable
+
+  function generate() {
+    input.value = Slug.create()
+    input.gotoLineEnd()
+  }
+
+  function confirm() {
+    props.onConfirm(slugify(input.value) || Slug.create())
+  }
+
+  useBindings(() => ({
+    target: inputTarget,
+    enabled: inputTarget() !== undefined,
+    priority: 1,
+    commands: [
+      {
+        name: "dialog.project_copy.generate",
+        title: "Generate project copy name",
+        category: "Dialog",
+        run: generate,
+      },
+    ],
+    bindings: tuiConfig.keybinds.get("dialog.project_copy.generate"),
+  }))
+
+  onMount(() => {
+    dialog.setSize("medium")
+    setTimeout(() => {
+      if (!input || input.isDestroyed) return
+      input.focus()
+    }, 1)
+  })
+
+  return (
+    <box paddingLeft={2} paddingRight={2} gap={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text attributes={TextAttributes.BOLD} fg={theme.text}>
+          Name project copy
+        </text>
+        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <input
+        ref={(value: InputRenderable) => {
+          input = value
+          setInputTarget(value)
+        }}
+        onSubmit={confirm}
+        placeholder="Project copy name"
+        placeholderColor={theme.textMuted}
+        textColor={theme.text}
+        focusedTextColor={theme.text}
+        cursorColor={theme.text}
+      />
+      <box paddingBottom={1} flexDirection="row" gap={2}>
+        <text fg={theme.text}>
+          enter <span style={{ fg: theme.textMuted }}>submit</span>
+        </text>
+        <text fg={theme.text}>
+          {generateShortcut()} <span style={{ fg: theme.textMuted }}>generate one</span>
+        </text>
+      </box>
+    </box>
+  )
+}
+
+DialogProjectCopyName.show = (dialog: DialogContext) =>
+  new Promise<string | null>((resolve) => {
+    dialog.replace(() => <DialogProjectCopyName onConfirm={resolve} />, () => resolve(null))
+  })
+
+function slugify(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "")
+}
@@ -218,7 +218,10 @@ export function Prompt(props: PromptProps) {
  const editorContextLabelState = createMemo(() => editor.labelState())
  const [auto, setAuto] = createSignal<AutocompleteRef>()
  const workspace = usePromptWorkspace(props.sessionID)
-  const move = usePromptMove({ projectID: project.project, sessionID: () => props.sessionID })
+  const move = usePromptMove({
+    projectID: () => (props.sessionID ? data.session.get(props.sessionID)?.projectID : undefined) ?? project.project(),
+    sessionID: () => props.sessionID,
+  })
  const [cursorVersion, setCursorVersion] = createSignal(0)
  const currentProviderLabel = createMemo(() => local.model.parsed().provider)
  const connected = useConnected()
@@ -955,13 +958,13 @@ export function Prompt(props: PromptProps) {
    if (workspace.creating() || move.creating()) return false
    if (auto()?.visible) return false
    if (!store.prompt.text) return false
-    const agent = local.agent.current()
-    if (!agent) return false
    const trimmed = store.prompt.text.trim()
    if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") {
      void exit()
      return true
    }
+    const agent = local.agent.current()
+    if (!agent) return false
    const selectedModel = local.model.current()
    if (!selectedModel) {
      void promptModelWarning()
@@ -991,7 +994,7 @@ export function Prompt(props: PromptProps) {
      const selectedWorkspace = workspace.selection()
      const workspaceID = selectedWorkspace?.type === "existing" ? selectedWorkspace.workspaceID : undefined

-      const directory = await move.getDirectory(store.prompt.text)
+      const directory = await move.getDirectory()
      if (move.pending() && !directory) return false
      finishMoveProgress = Boolean(move.progress())
      const location = data.location.default()
@@ -4,12 +4,12 @@ import { useTuiPaths } from "../../context/runtime"
 import { errorMessage } from "../../util/error"
 import { useDialog } from "../../ui/dialog"
 import { useSDK } from "../../context/sdk"
-import { useSync } from "../../context/sync"
 import { useToast } from "../../ui/toast"
 import { DialogMoveSession, type MoveSessionSelection } from "../dialog-move-session"
 import { DialogWorkspaceFileChanges } from "../dialog-workspace-file-changes"
 import { useHomeSessionDestination } from "../../routes/home/session-destination"
 import { useProject } from "../../context/project"
+import { useData } from "../../context/data"

 function moveReminderText(directory: string) {
  return `<system-reminder>The user has changed the current working directory to "${directory}". This is still the same project but at a possibly new location; take this into account when working with any files from now on.</system-reminder>`
@@ -18,38 +18,33 @@ function moveReminderText(directory: string) {
 export function usePromptMove(input: { projectID: () => string | undefined; sessionID: () => string | undefined }) {
  const dialog = useDialog()
  const sdk = useSDK()
-  const sync = useSync()
  const toast = useToast()
  const homeDestination = useHomeSessionDestination()
  const project = useProject()
+  const data = useData()
  const paths = useTuiPaths()
  const [creating, setCreating] = createSignal(false)
  const [creatingDots, setCreatingDots] = createSignal(3)
  const [progress, setProgress] = createSignal<string>()

-  async function create(context?: string) {
-    const projectID = input.projectID()
+  async function create(name: string) {
+    const projectID = await resolveProjectID()
    if (!projectID) return
    setCreating(true)
    setProgress("Creating copy")
    try {
-      const generated = await sdk.client.experimental.projectCopy.generateName(
-        { projectID, context },
-        { throwOnError: true },
-      )
      const result = await sdk.api.projectCopy.create({
        projectID,
        location: { directory: project.instance.directory() || paths.cwd },
        strategy: "git_worktree",
        directory: path.join(paths.worktree, projectID.slice(0, 6)),
-        name: generated.data.name,
+        name,
      })
      const directory = result.directory
      if (!directory) throw new Error("No project copy directory returned")

-      // Call a location-based route to make sure it's bootstrapped
-      // before moving on
-      await sdk.client.path.get({ directory }, { throwOnError: true })
+      // Call a location-based route to make sure it's bootstrapped before moving on.
+      await sdk.api.location.get({ location: { directory } })

      setProgress("Creating session")
      return directory
@@ -62,11 +57,14 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
    }
  }

-  function open() {
-    const projectID = input.projectID()
-    if (!projectID) return
+  async function open() {
+    const projectID = await resolveProjectID()
+    if (!projectID) {
+      toast.show({ message: "Unable to determine current project", variant: "error" })
+      return
+    }
    const sessionID = input.sessionID()
-    const session = sessionID ? sync.session.get(sessionID) : undefined
+    const session = sessionID ? await resolveSession(sessionID) : undefined
    dialog.replace(() => (
      <DialogMoveSession
        projectID={projectID}
@@ -75,8 +73,8 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
          (session
            ? {
                type: "directory",
-                directory: session.directory,
-                subdirectory: !!session.path,
+                directory: session.location.directory,
+                subdirectory: !!session.subpath,
              }
            : {
                type: "directory",
@@ -98,26 +96,13 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
    ))
  }

-  function sessionContext(sessionID: string) {
-    const session = sync.session.get(sessionID)
-    const messages = (sync.data.message[sessionID] ?? [])
-      .slice(-6)
-      .map((message) =>
-        [
-          message.role + ":",
-          ...(sync.data.part[message.id] ?? []).flatMap((part) => (part.type === "text" ? [part.text] : [])),
-        ].join(" "),
-      )
-    return [session?.title, ...messages].filter(Boolean).join("\n") || undefined
-  }
-
  async function moveExistingSession(sessionID: string, selection: MoveSessionSelection) {
-    const session = sync.session.get(sessionID)
-    const status = await sdk.client.vcs.status({ directory: session?.directory }).catch(() => undefined)
+    const session = await resolveSession(sessionID)
+    const status = await sdk.client.vcs.status({ directory: session?.location.directory }).catch(() => undefined)
    const choice = status?.data?.length ? await DialogWorkspaceFileChanges.show(dialog, status.data) : "no"
    if (!choice) return
    dialog.clear()
-    const directory = selection.type === "new" ? await create(sessionContext(sessionID)) : selection.directory
+    const directory = selection.type === "new" ? await create(selection.name) : selection.directory
    if (!directory) {
      setProgress(undefined)
      dialog.clear()
@@ -125,27 +110,9 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
    }
    setProgress("Moving session")
    try {
-      await sdk.client.experimental.controlPlane.moveSession(
-        {
-          sessionID,
-          destination: { directory },
-          moveChanges: choice === "yes",
-        },
-        { throwOnError: true },
-      )
-      await sdk.client.session
-        .promptAsync({
-          sessionID,
-          directory,
-          noReply: true,
-          parts: [
-            {
-              type: "text",
-              text: moveReminderText(directory),
-              synthetic: true,
-            },
-          ],
-        })
+      await sdk.api.session.move({ sessionID, destination: { directory }, moveChanges: choice === "yes" })
+      await sdk.api.session
+        .synthetic({ sessionID, text: moveReminderText(directory), resume: false })
        .catch(() => undefined)
      dialog.clear()
    } catch (error) {
@@ -157,16 +124,34 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
    }
  }

+  async function resolveProjectID() {
+    const projectID = input.projectID()
+    if (projectID) return projectID
+    const sessionID = input.sessionID()
+    if (sessionID) return (await resolveSession(sessionID))?.projectID
+    return sdk.api.project
+      .current({ location: { directory: project.instance.directory() || paths.cwd } })
+      .then((project) => project.id)
+      .catch(() => undefined)
+  }
+
+  async function resolveSession(sessionID: string) {
+    const session = data.session.get(sessionID)
+    if (session) return session
+    await data.session.refresh(sessionID).catch(() => undefined)
+    return data.session.get(sessionID)
+  }
+
  const pending = createMemo(() => Boolean(homeDestination?.destination()))
  const pendingNew = createMemo(() => homeDestination?.destination()?.type === "new")

-  async function getDirectory(context?: string) {
+  async function getDirectory() {
    const value = homeDestination?.destination()
    if (!value) return
    if (value.type === "directory") {
      return value.directory
    }
-    return await create(context)
+    return await create(value.name)
  }

  function startSubmit() {
@@ -207,6 +207,7 @@ export const Definitions = {
  "dialog.select.end": keybind("end", "Move to last dialog item"),
  "dialog.select.submit": keybind("return", "Submit selected dialog item"),
  "dialog.prompt.submit": keybind("return", "Submit dialog prompt"),
+  "dialog.project_copy.generate": keybind("tab", "Generate project copy name"),
  "dialog.mcp.toggle": keybind("space", "Toggle MCP in MCP dialog"),
  "dialog.move_session.new": keybind("ctrl+m", "New project copy"),
  "dialog.move_session.delete": keybind("ctrl+d", "Delete project copy"),
@@ -304,6 +304,12 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
          if (store.session.info[event.data.sessionID])
            setStore("session", "info", event.data.sessionID, "title", event.data.title)
          break
+        case "session.moved":
+          if (store.session.info[event.data.sessionID]) {
+            setStore("session", "info", event.data.sessionID, "location", mutable(event.data.location))
+            setStore("session", "info", event.data.sessionID, "subpath", event.data.subpath)
+          }
+          break
        case "session.prompt.promoted": {
          message.update(event.data.sessionID, (draft, index) => {
            const position = index.get(event.data.inputID)
@@ -6,7 +6,7 @@ import { useTuiPaths } from "../../context/runtime"

 const id = "internal:sidebar-footer"

-function View(props: { api: TuiPluginApi; sessionID: string }) {
+function View(props: { api: TuiPluginApi; directory: string }) {
  const paths = useTuiPaths()
  const theme = () => props.api.theme.current
  const has = createMemo(() =>
@@ -17,10 +17,8 @@ function View(props: { api: TuiPluginApi; sessionID: string }) {
  const done = createMemo(() => props.api.kv.get("dismissed_getting_started", false))
  const show = createMemo(() => !has() && !done())
  const path = createMemo(() => {
-    const session = props.api.state.session.get(props.sessionID)
-    const dir = session?.directory || props.api.state.path.directory || paths.cwd
-    const out = abbreviateHome(dir, paths.home)
-    const branch = session?.directory === props.api.state.path.directory ? props.api.state.vcs?.branch : undefined
+    const out = abbreviateHome(props.directory, paths.home)
+    const branch = props.directory === props.api.state.path.directory ? props.api.state.vcs?.branch : undefined
    const text = branch ? out + ":" + branch : out
    const list = text.split("/")
    return {
@@ -84,7 +82,7 @@ const tui: TuiPlugin = async (api) => {
    order: 100,
    slots: {
      sidebar_footer(_ctx, props) {
-        return <View api={api} sessionID={props.session_id} />
+        return <View api={api} directory={props.directory} />
      },
    },
  })
@@ -10,7 +10,7 @@ import {
 import { useSync } from "../../context/sync"
 import { useTuiPaths } from "../../context/runtime"

-export type HomeSessionDestination = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new" }
+export type HomeSessionDestination = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new"; name: string }

 type Context = {
  destination: Accessor<HomeSessionDestination | undefined>
@@ -85,7 +85,12 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
        </scrollbox>

        <box flexShrink={0} gap={1} paddingTop={1}>
-          <pluginRuntime.Slot name="sidebar_footer" mode="single_winner" session_id={props.sessionID}>
+          <pluginRuntime.Slot
+            name="sidebar_footer"
+            mode="single_winner"
+            session_id={props.sessionID}
+            directory={session()?.location.directory ?? ""}
+          >
            <text fg={theme.textMuted}>
              <span style={{ fg: theme.success }}>•</span> <b>Open</b>
              <span style={{ fg: theme.text }}>
@@ -108,6 +108,68 @@ test("refreshes resources into reactive getters", async () => {
  }
 })

+test("updates session location when moved", async () => {
+  const events = createEventStream()
+  const destination = "/tmp/opencode-moved"
+  const calls = createFetch((url) => {
+    if (url.pathname === "/api/session/ses_test")
+      return json({
+        data: {
+          id: "ses_test",
+          projectID: "proj_test",
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          time: { created: 0, updated: 0 },
+          title: "Test session",
+          location: { directory },
+        },
+      })
+  }, events)
+  let data!: ReturnType<typeof useData>
+  let ready!: () => void
+  const mounted = new Promise<void>((resolve) => {
+    ready = resolve
+  })
+
+  function Probe() {
+    data = useData()
+    onMount(ready)
+    return <box />
+  }
+
+  const app = await testRender(() => (
+    <TestTuiContexts>
+      <SDKProvider client={createClient(calls.fetch)} api={createApi(calls.fetch)}>
+        <ProjectProvider>
+          <DataProvider>
+            <Probe />
+          </DataProvider>
+        </ProjectProvider>
+      </SDKProvider>
+    </TestTuiContexts>
+  ))
+
+  try {
+    await mounted
+    await data.session.refresh("ses_test")
+    emitEvent(events, {
+      id: "evt_moved_1",
+      created: 1,
+      type: "session.moved",
+      durable: durable("ses_test"),
+      data: {
+        sessionID: "ses_test",
+        location: { directory: destination },
+        subpath: "packages/cli",
+      },
+    })
+    await wait(() => data.session.get("ses_test")?.location.directory === destination)
+    expect(data.session.get("ses_test")?.subpath).toBe("packages/cli")
+  } finally {
+    app.renderer.destroy()
+  }
+})
+
 test("restores running manual compaction before applying live deltas", async () => {
  const events = createEventStream()
  const calls = createFetch((url) => {
Author	SHA1	Message	Date
Aiden Cline	f3c28008de	docs(codemode): clarify output byte budget	2026-07-08 13:50:31 -05:00
Aiden Cline	b2f5c07fd1	fix(codemode): preserve floating rejection results	2026-07-08 12:02:27 -05:00
Aiden Cline	7dc72f5cc4	fix(codemode): release settled promise state	2026-07-07 16:03:59 -05:00
Aiden Cline	cd64a45512	fix(codemode): scope promises to executions	2026-07-07 15:58:08 -05:00
Aiden Cline	326dd7e8e7	fix(codemode): return promises from combinators	2026-07-07 14:01:28 -05:00
James Long	da68e2865e	feat(tui): wire move session command (#35203 )	2026-07-07 14:49:11 -04:00
Aiden Cline	f86e1cc1ff	fix(codemode): preserve collection value identity (#35776 )	2026-07-07 13:40:55 -05:00
Aiden Cline	947bbf9490	feat(mcp): expose resource catalog API (#35773 )	2026-07-07 13:34:29 -05:00
James Long	3e57b43a4a	feat(session): support admit-only synthetic messages (#35774 )	2026-07-07 14:17:20 -04:00
opencode-agent[bot]	cb18a42a47	docs(codemode): clarify implicit return guidance (#35763 ) Co-authored-by: Kit Langton <kit.langton@gmail.com>	2026-07-07 12:48:05 -05:00
Aiden Cline	1fb2837fd3	feat(codemode): expand numeric standard library (#35749 )	2026-07-07 12:11:57 -05:00
Aiden Cline	66a8d830aa	feat(core): support MCP resources (#35656 )	2026-07-07 11:55:06 -05: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