fix(codemode): enumerate inherited keys in for...in, intern tool references, freeze template objects, and delegate Array and Error toString

fix(core): keep thinking on for Claude Opus 5.5 variants (#51338 )
fix(ai): preserve Gemini 3.8 TTS WAV output (#51300 )
2026-09-25 18:17:35 +00:00 · 2026-09-25 12:01:22 -05:00 · 2026-09-25 18:32:41 +05:30 · 2026-09-25 18:11:36 +05:30 · 2026-09-25 14:36:29 +02:00 · 2026-09-25 12:21:04 +00:00
106 changed files with 4182 additions and 976 deletions
@@ -597,8 +597,8 @@
      },
      "peerDependencies": {
        "@opencode/theme": "workspace:*",
-        "@opentui/core": ">=0.5.10",
-        "@opentui/solid": ">=0.5.10",
+        "@opentui/core": ">=0.5.12",
+        "@opentui/solid": ">=0.5.12",
        "solid-js": ">=1.9.0",
      },
      "optionalPeers": [
@@ -1114,9 +1114,9 @@
    "@npmcli/arborist": "9.4.0",
    "@octokit/rest": "22.0.0",
    "@openauthjs/openauth": "0.0.0-20250322224806",
-    "@opentui/core": "0.5.10",
-    "@opentui/keymap": "0.5.10",
-    "@opentui/solid": "0.5.10",
+    "@opentui/core": "0.5.12",
+    "@opentui/keymap": "0.5.12",
+    "@opentui/solid": "0.5.12",
    "@pierre/diffs": "1.2.10",
    "@playwright/test": "1.59.1",
    "@sentry/solid": "10.71.0",
@@ -2252,27 +2252,27 @@

    "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="],

-    "@opentui/core": ["@opentui/core@0.5.10", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.10", "@opentui/core-darwin-x64": "0.5.10", "@opentui/core-linux-arm64": "0.5.10", "@opentui/core-linux-arm64-musl": "0.5.10", "@opentui/core-linux-x64": "0.5.10", "@opentui/core-linux-x64-musl": "0.5.10", "@opentui/core-win32-arm64": "0.5.10", "@opentui/core-win32-x64": "0.5.10" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-C3a2UbmefeAjIxAgm4BqjuSxKT4oqutfvYFwVvUgMxmGRHkNbBc/s7sukV0JgwcxFcV3uMFrXxo+E+BQtvuOiw=="],
+    "@opentui/core": ["@opentui/core@0.5.12", "", { "dependencies": { "bun-ffi-structs": "0.3.1", "diff": "9.0.0", "marked": "17.0.1", "string-width": "7.2.0", "strip-ansi": "7.1.2" }, "optionalDependencies": { "@opentui/core-darwin-arm64": "0.5.12", "@opentui/core-darwin-x64": "0.5.12", "@opentui/core-linux-arm64": "0.5.12", "@opentui/core-linux-arm64-musl": "0.5.12", "@opentui/core-linux-x64": "0.5.12", "@opentui/core-linux-x64-musl": "0.5.12", "@opentui/core-win32-arm64": "0.5.12", "@opentui/core-win32-x64": "0.5.12" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-ZXBE5gmvdovmV8zJQrOQf6E44v1tJRDEgrM2MYhEglzgXZ+smIUp95O8zeRYGsuIzQIiMPMgQqKtTJuzvAb7BQ=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Vyb+nTbhab8ZcRy5gg1loEEGwRcIbjAeVRIBfHBcbFDqmITBOg7x2gqJ+x/TnoOy4uwMhCmICUN2wiyREw3r1Q=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.5.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-YdVnP0tAyerBNl0mIcmQEOotPeZzW1VnSXKBl5cyZ5e6nDd2Y+ui/8eRPpn1oqcamf1NCnzS4ohMgejOvna8Zg=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-tTFLcM7Oj1gTyhm/bUdAt3C6grZdCxPk6+/g2azcZBUlI3/62LwbeRS6HbQKFFmm+1fUmX8cq6kWrtul885mVg=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.5.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-uRrQJdHmLUSj3PV23QPi3WSimYTTxcXnVouxF6U4xMXlOv4N3SxnHfVwMRQkPqbGOfvVWHeLE6FdK4C+ubU0sQ=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-ncJXcgudhBf2GdJyF3xVQN/Ec+1F7GOL+pRrURmgBYSj2v1w6EyoDQFAACtPTK2c3R38W6fvZwL4JSLlm4EFXQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.5.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-XeKhuIaEtgipvuPHbl4qPOBj+Ut+2zObmsxMVM1jDcjz/FatG9PGeGQPx1G1SnvH2AgpT4K+eCu7DUF0+yIqoQ=="],

-    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-dGMphDKexSdeYqwl0wgoFBP88Ta/cdi1Zc1mk29/ENkSCGz+74zlCHgqTHRNGLmI8W5TfuUtCyktQH11/Z+TBQ=="],
+    "@opentui/core-linux-arm64-musl": ["@opentui/core-linux-arm64-musl@0.5.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-VZ2sNMw1d/r1SLPjUbOP9LKscKz1CQjID8adTL6gG8Lrrq+mYcIUxutyB+P/eG0J/7oRZLPR6OMt7dUOap6RTg=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-5qtYaOgwVycZD1GaGshTRsi0rXPAmVExO03N1JQaHu+NYxK/vXSOc7Bu4QW0sPXx3Sp0SpzpP+FHjXABfoK66g=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.5.12", "", { "os": "linux", "cpu": "x64" }, "sha512-eZiCjEzwbb6qClPPfk32Nha9xmr9obt69Xj0+9SKsXxWLBKkjQEGOMRoh/R9ObaQF4aq8If1xV3VEY0sD9W9vg=="],

-    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-Oj4H9hApuvuTKPWxh4SoZAgGJorR7vbvnrZA/cAkSMAk2VGSoHRRcqeXQbcH8IcdjVZ0KFpv8Zkl/D5Ye+2mew=="],
+    "@opentui/core-linux-x64-musl": ["@opentui/core-linux-x64-musl@0.5.12", "", { "os": "linux", "cpu": "x64" }, "sha512-WWW0hVBoSYZ3D6AgZ4u2Y5/u/IyIq2pDb+4yI3WgJ70Wyt6ofHy+6kRGRgbXFn1p+rPInAHjCXD2v6C7iEKSrA=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-A9VhgvTxQoUdZ+8LmUumEng1sQNbj9QQQT3NYG9mSxI54qTANi7vOWNSphMiY6RMVsr22pgm6nUvSSvJXv7Jog=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.5.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-aLbm6870Ybls6CYL4zMOCImTBPLZHZMUXJFGqMI44lIWxitkAtT6zg5lYA4oRqFRzzryDclxr29+hDgT3p3Blw=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.10", "", { "os": "win32", "cpu": "x64" }, "sha512-u3KHa7kEeWrmKVDRJYpxSGO+g5E9cMGlrmTsPN3GVPHUmQMiREUawLXUvsU8+IHaQnqG3Q5nuE1yf4fPBzS+Qw=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.5.12", "", { "os": "win32", "cpu": "x64" }, "sha512-KTwtwpfd2zF9opVh3SyRJYDd1o3Xv4XL8OZb8Zi+CqWUel6Y2IDCiVivCv8fGJt3J7wOIXXtuZI9ZUkLyKJCiQ=="],

-    "@opentui/keymap": ["@opentui/keymap@0.5.10", "", { "dependencies": { "@opentui/core": "0.5.10" }, "peerDependencies": { "@opentui/react": "0.5.10", "@opentui/solid": "0.5.10", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-8vDJF+ltXscSnLEv3rgCa4m7PcoYZeUT9BngugpFCmVoNevbaRtYijjdfiUuLmXfT61lO5QbR6nEhn2RZMK8ow=="],
+    "@opentui/keymap": ["@opentui/keymap@0.5.12", "", { "dependencies": { "@opentui/core": "0.5.12" }, "peerDependencies": { "@opentui/react": "0.5.12", "@opentui/solid": "0.5.12", "react": ">=19.2.0", "solid-js": "1.9.12" }, "optionalPeers": ["@opentui/react", "@opentui/solid", "react", "solid-js"] }, "sha512-yWPvJjRhJTRoRSUucQq9Ua8ZW7n/2YQ/j6JxWq5Qekm4WuFiTplEkebR/Aj2/xA8tX68NOE5qv1LrY0Jk3NLNQ=="],

-    "@opentui/solid": ["@opentui/solid@0.5.10", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.10", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-KrmMIsHiKBHOABTC0brOwqWm+sGq1ZX2sGCAx6WgtBbE3STMup9n8TAy/6gUYhwcjC9zugT53ytfSVwCwVWZUg=="],
+    "@opentui/solid": ["@opentui/solid@0.5.12", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.5.12", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.12", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.12" } }, "sha512-hAiVlVMtT7AkHGblKwcW1YAuXtxkSy1XSf/RRc4j3IlG3mTNX0bhJdnGOo3Xw14EqeZMp41Mcp5WzHAzMm/DzA=="],

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

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-+Clo0VPDdruHSoBNvV/wKAM8iR6HJPtB00oa8yl9ujU=",
-    "aarch64-linux": "sha256-4wU5v36GTXjwyt5ls4FH+5G43Ujd+dKVSJR21w3lhbA=",
-    "aarch64-darwin": "sha256-pThjoD6baddQ6biy7k1ByXwGwLAeWe/+w0tcYmt1uWs=",
-    "x86_64-darwin": "sha256-bCBl63CqBiqilb+YdaOLBYYZx/yf47c1aqgDOkgdegg="
+    "x86_64-linux": "sha256-aQQQhaUlAhpfqzH0vNi0IJ1cg7FQHIKYzxeq5d8PZoU=",
+    "aarch64-linux": "sha256-r9aDFu3UYmudmmYPhzCrpFvQlaejXc8V1IzLtG3jZPc=",
+    "aarch64-darwin": "sha256-B0m41LelD7d61vPHGIZZSO/cU7gbjHDJHt6oxNRRM8Q=",
+    "x86_64-darwin": "sha256-9TWJsyI3Y6BMomtGSgqA1th9LpxpqP4F5Tl/GyexVYw="
  }
 }
@@ -52,9 +52,9 @@
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.10",
-      "@opentui/keymap": "0.5.10",
-      "@opentui/solid": "0.5.10",
+      "@opentui/core": "0.5.12",
+      "@opentui/keymap": "0.5.12",
+      "@opentui/solid": "0.5.12",
      "@tanstack/solid-virtual": "3.13.37",
      "@shikijs/stream": "4.4.3",
      "@standard-schema/spec": "1.1.0",
@@ -56,10 +56,15 @@ interface State extends SpeechStream.Audio, GeminiGenerateContent.Metadata {
 // ---------------------------------------------------------------------------

 const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request: MediaProtocol.Addressed<Request>) {
+  if (request.format === "pcm" && request.mode === "generate" && /^gemini-3\.8-.*-tts(?:-|$)/.test(request.model.id))
+    return yield* route.unsupported(
+      "media.format",
+      `${route.name} returns WAV by default for Gemini 3.8 TTS unary requests; omit the format to accept it`,
+    )
  if (request.format !== undefined && request.format !== "pcm")
    return yield* route.unsupported(
      "media.format",
-      `${route.name} only returns raw PCM; request format "pcm" or omit it, then wrap the samples yourself`,
+      `${route.name} only accepts raw PCM as an explicit format; omit it to accept the provider's default output`,
    )
  const voiceName = SpeechStream.voiceID(request.voice)
  return MediaProtocol.json(
@@ -97,10 +102,18 @@ const step = Effect.fn("GoogleSpeech.step")(function* (state: State, frame: stri
  return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])] as const
 })

-const finish = (state: State) => {
+const finish = (state: State, context: MediaProtocol.ResponseContext<Request>) => {
  const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE
+  const output =
+    state.mimeType?.split(";")[0]?.toLowerCase() === "audio/wav"
+      ? SpeechStream.container("wav", sampleRate)
+      : SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`)
+  if (context.request.format === "pcm" && output.info.format !== "pcm")
+    return Effect.fail(
+      route.frameError(`Google Speech returned ${output.info.format} instead of the requested raw PCM`),
+    )
  return SpeechStream.finish(route, state, {
-    ...SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`),
+    ...output,
    usage: GeminiGenerateContent.usage(state.usage),
    providerMetadata: GeminiGenerateContent.providerMetadata(state),
    detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
@@ -28,10 +28,49 @@ const cartesia = Cartesia.configure({ apiKey: "test", baseURL: "https://cartesia
 const google = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
  "gemini-2.5-flash-preview-tts",
 )
+const google38 = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
+  "gemini-3.8-flash-tts",
+)
+const google38Lite = Google.configure({ apiKey: "test", baseURL: "https://google.test/v1beta" }).speech(
+  "gemini-3.8-flash-lite-tts",
+)
 const deepgram = Deepgram.configure({ apiKey: "test", baseURL: "https://deepgram.test" }).speech("aura-2-thalia-en")
 const voice = "JBFqnCBsd6RMkjVDRZzb"

 describe("Speech", () => {
+  it.effect("preserves Google's WAV output instead of describing it as raw PCM", () =>
+    Effect.gen(function* () {
+      const bytes = new TextEncoder().encode("RIFF....WAVEfmt ")
+      const response = yield* Speech.generate({ model: google38, text: "Hi" }).pipe(
+        Effect.provide(
+          respond(
+            JSON.stringify({
+              candidates: [
+                { content: { parts: [{ inlineData: { mimeType: "audio/wav", data: Encoding.encodeBase64(bytes) } }] } },
+              ],
+            }),
+            "application/json",
+          ),
+        ),
+      )
+      expect(response.audio.mediaType).toBe("audio/wav")
+      expect(response.audio.info?.format).toBe("wav")
+      expect(response.audio.info?.encoding).toBeUndefined()
+      expect(yield* response.audio.bytes()).toEqual(bytes)
+    }),
+  )
+
+  it.effect("rejects raw PCM for Gemini 3.8 unary requests before sending", () =>
+    Effect.gen(function* () {
+      const errors = yield* Effect.all(
+        [google38, google38Lite].map((model) =>
+          Speech.generate({ model, text: "Hi", format: "pcm" }).pipe(Effect.flip),
+        ),
+      ).pipe(Effect.provide(layer(() => Effect.die("An unsupported request reached the network"))))
+      expect(errors.map((error) => error.reason._tag)).toEqual(["UnsupportedOperation", "UnsupportedOperation"])
+    }),
+  )
+
  it.effect("rejects what a provider cannot produce before sending anything", () =>
    Effect.gen(function* () {
      const errors = yield* Effect.all(
@@ -2,7 +2,7 @@ import { DialogProvider } from "@opencode/ui/context/dialog"
 import { Browser } from "@opencode/plugin-browser/rpc"
 import { For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { render } from "solid-js/web"
+import { Portal, render } from "solid-js/web"
 import { LanguageProvider, UiI18nBridge } from "../src/runtime/i18n/language"
 import type { BrowserPaneLayout, BrowserPaneRegistration } from "../src/runtime/platform/browser-pane"
 import type { createSessionBrowser } from "../src/session/browser/model"
@@ -27,7 +27,12 @@ export function mountBrowserPane() {
      loadErrors: {} as Record<string, string | undefined>,
      error: undefined as string | undefined,
      layouts: {} as Record<string, BrowserPaneLayout | undefined>,
+      covered: false,
+      captures: 0,
+      holdCapture: false,
    })
+    // Each capture waits until the fixture releases it, so a spec can observe the pending state.
+    const held: (() => void)[] = []
    const tabs = ["Alpha", "Beta"].map((name) => ({
      id: Browser.TabID.make(`tab_${name === "Alpha" ? "11111111" : "22222222"}-1111-1111-1111-111111111111`),
      title: name,
@@ -44,6 +49,17 @@ export function mountBrowserPane() {
        {
          setLayout: (layout) => setStore("layouts", tab.title, layout),
          command: async () => undefined,
+          capture: async () => {
+            setStore("captures", (count) => count + 1)
+            if (store.holdCapture) await new Promise<void>((resolve) => held.push(resolve))
+            const canvas = new OffscreenCanvas(4, 4)
+            const paint = canvas.getContext("2d")
+            if (paint) {
+              paint.fillStyle = "#3b82f6"
+              paint.fillRect(0, 0, 4, 4)
+            }
+            return canvas.convertToBlob()
+          },
          close: () => undefined,
        },
      ]),
@@ -118,12 +134,34 @@ export function mountBrowserPane() {
            Complete navigation
          </button>
          <button onClick={() => setStore("visible", (visible) => !visible)}>Toggle Review tab</button>
+          <button onClick={() => setStore("holdCapture", true)}>Hold capture</button>
+          <button onClick={() => held.splice(0).forEach((resolve) => resolve())}>Release capture</button>
+          <button onClick={() => setStore("covered", (covered) => !covered)}>Toggle popover</button>
        </nav>
-        <div style={{ width: "640px", height: "360px", border: "1px solid #555" }}>
+        <p>Captures: {store.captures}</p>
+        <div style={{ position: "relative", width: "640px", height: "360px", border: "1px solid #555" }}>
          <Show when={store.mounted}>
            <SessionBrowserPane browser={browser} visible={store.visible} />
          </Show>
        </div>
+        <Show when={store.covered}>
+          {/* Floating content portals into <body> like a menu or hover card over the page. */}
+          <Portal mount={document.body}>
+            <div
+              data-popper-positioner
+              data-testid="fixture-popover"
+              style={{
+                position: "fixed",
+                top: "0",
+                left: "0",
+                width: "320px",
+                height: "480px",
+                "z-index": "1001",
+                "pointer-events": "none",
+              }}
+            />
+          </Portal>
+        </Show>
        <h2 style={{ "font-size": "18px", margin: "20px 0 12px" }}>Native layout recorder</h2>
        <p>The desktop boundary keeps each session's page visible until its registration is hidden.</p>
        <For each={tabs}>
@@ -58,6 +58,27 @@ story("hides the native view immediately while the pane stays mounted", async ({
  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
 })

+story("keeps a still of the page under floating content that covers it", async ({ page }, testInfo) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const still = root.locator("#browser-panel img")
+  await root.getByRole("button", { name: "Hold capture", exact: true }).click()
+  await root.getByRole("button", { name: "Toggle popover", exact: true }).click()
+  await expect(root.getByText("Captures: 1", { exact: true })).toBeVisible()
+  // The native page stays up until its still is ready, so the pane never shows blank.
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(still).toHaveCount(0)
+
+  await root.getByRole("button", { name: "Release capture", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(still).toBeVisible()
+  await page.screenshot({ path: testInfo.outputPath("covered.png") })
+
+  await root.getByRole("button", { name: "Toggle popover", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(still).toHaveCount(0)
+  await expect(root.getByText("Captures: 1", { exact: true })).toBeVisible()
+})
+
 story("shows the empty state over a blank native page and restores navigation", async ({ page }) => {
  const root = page.getByTestId("browser-pane-fixture")
  await root.getByRole("button", { name: "Blank page", exact: true }).click()
@@ -1,5 +1,5 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent, SessionMessageInfo } from "@opencode/client/promise"
+import type { OpenCodeEvent, SessionInboxInfo, SessionMessageInfo } from "@opencode/client/promise"
 import { base64Encode } from "@opencode/util/encode"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -14,7 +14,12 @@ type InboxRow = {
  sessionID: string
  time: { created: number }
  type: "user"
-  payload: { text: string; metadata?: Record<string, unknown> }
+  payload: {
+    text: string
+    metadata?: Record<string, unknown>
+    files?: Extract<SessionInboxInfo, { type: "user" }>["payload"]["files"]
+    agents?: Extract<SessionInboxInfo, { type: "user" }>["payload"]["agents"]
+  }
  delivery: "steer" | "queue"
 }

@@ -29,7 +34,7 @@ function createQueueMock(seed: string[], messages: SessionMessageInfo[] = []) {
  }))
  const events: OpenCodeEvent[] = []
  const prompts: Record<string, unknown>[] = []
-  const changes: { inboxID: string; action: "cancel" | "steer" }[] = []
+  const changes: { inboxID: string; action: "cancel" | "steer" | "queue" }[] = []
  const log: string[] = []
  let sequence = 0
  const emit = <Type extends OpenCodeEvent["type"]>(
@@ -234,6 +239,108 @@ test("editing restores the existing draft and replaces only the original queue p
  expect(mock.log[0]).toBe("prompt:queue")
 })

+test("Undo cancels only the selected queued prompt and focuses the restored input", async ({ page }) => {
+  const mock = createQueueMock(["first queued prompt", "second queued prompt", "third queued prompt"])
+  const view = await openSession(page, mock)
+  await expect(view.rows).toHaveCount(3)
+
+  const row = view.rows.filter({ hasText: "second queued prompt" })
+  const actions = row.locator('[data-slot="session-queue-actions"] button')
+  await expect(actions).toHaveCount(3)
+  expect(
+    await actions.evaluateAll((buttons) =>
+      buttons.map((button) => button.getAttribute("aria-label") ?? button.textContent?.trim()),
+    ),
+  ).toEqual(["Steer", "Undo", "Remove"])
+  const undo = row.getByRole("button", { name: "Undo" })
+  await expect(undo).toHaveText("")
+  await expect(undo.locator("svg use")).toHaveAttribute("href", "#opencode-v2-icon-arrow-down-to-line")
+  await undo.hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Undo")
+  await undo.click()
+  await expect(view.rows.locator('[data-action="session-queue-edit"]')).toHaveText([
+    "first queued prompt",
+    "third queued prompt",
+  ])
+  await expect(view.input).toHaveText("second queued prompt")
+  await expect(view.input).toBeFocused()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_2", action: "cancel" }])
+  expect(mock.prompts).toEqual([])
+})
+
+test("Undo appends to an existing draft and restores inline attachments", async ({ page }) => {
+  const mock = createQueueMock(["queued with image"])
+  mock.rows[0].payload.files = [
+    {
+      data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIHWP4z8DwHwAFgAI/ScL/nwAAAABJRU5ErkJggg==",
+      mime: "image/png",
+      source: { type: "inline" },
+      name: "shot.png",
+    },
+  ]
+  const view = await openSession(page, mock)
+  await view.input.fill("my draft")
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(view.rows).toHaveCount(0)
+  await expect(view.input).toHaveText("my draft\n\nqueued with image")
+  await expect(view.input).toBeFocused()
+  await expect(view.composer.getByRole("img", { name: "shot.png" })).toBeVisible()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_1", action: "cancel" }])
+})
+
+test("Undo stays usable with a long queue on a narrow screen", async ({ page }, testInfo) => {
+  await page.setViewportSize({ width: 390, height: 844 })
+  const text = "Review the detailed error report and check every step of the retry path ".repeat(4)
+  const mock = createQueueMock([text, ...Array.from({ length: 6 }, (_, index) => `queued follow-up ${index + 1}`)])
+  const view = await openSession(page, mock)
+  await expect(view.rows).toHaveCount(7)
+  const row = view.rows.filter({ hasText: text })
+  await row.getByRole("button", { name: "Undo" }).hover()
+  await expect(page.getByRole("tooltip")).toHaveText("Undo")
+  await page.screenshot({ path: testInfo.outputPath("undo-narrow-queue.png") })
+  await row.getByRole("button", { name: "Undo" }).click()
+  await expect(view.rows).toHaveCount(6)
+  await expect(view.input).toHaveText(text)
+  await expect(view.input).toBeFocused()
+  expect(mock.changes).toEqual([{ inboxID: "inb_seed_1", action: "cancel" }])
+})
+
+test("Undo preserves mentioned file and agent references on resubmission", async ({ page }) => {
+  const mock = createQueueMock(["inspect @main.ts with @build"])
+  mock.rows[0].payload.files = [
+    {
+      data: "aGk=",
+      mime: "text/plain",
+      source: { type: "uri", uri: "file:///repo/main.ts" },
+      name: "main.ts",
+      mention: { start: 8, end: 16, text: "@main.ts" },
+    },
+  ]
+  mock.rows[0].payload.agents = [{ name: "build", mention: { start: 22, end: 28, text: "@build" } }]
+  const view = await openSession(page, mock)
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(view.input).toHaveText("inspect @main.ts with @build")
+  await view.input.press("Enter")
+  await expect.poll(() => mock.prompts.length).toBe(1)
+  expect(mock.prompts[0].files).toMatchObject([
+    { uri: "data:text/plain;base64,aGk=", mention: { text: "@main.ts", start: 8, end: 16 } },
+  ])
+  expect(mock.prompts[0].agents).toMatchObject([{ name: "build", mention: { text: "@build" } }])
+})
+
+test("Undo does not discard hidden file context", async ({ page }) => {
+  const mock = createQueueMock(["inspect this file"])
+  mock.rows[0].payload.files = [
+    { data: "aGk=", mime: "text/plain", source: { type: "uri", uri: "file:///repo/main.ts" }, name: "main.ts" },
+  ]
+  const view = await openSession(page, mock)
+  await view.rows.getByRole("button", { name: "Undo" }).click()
+  await expect(page.getByText("Edit this prompt in the queue to preserve its file context")).toBeVisible()
+  await expect(view.rows).toHaveCount(1)
+  await expect(view.input).toHaveText("")
+  expect(mock.changes).toEqual([])
+})
+
 for (const delivery of ["steer", "queue"] as const) {
  test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up`, async ({
    page,
@@ -47,6 +47,7 @@ export type ComposerDelivery = "steer" | "queue"
 // is loaded in the editor.
 export type ComposerQueue = {
  count: Accessor<number>
+  undoing: Accessor<boolean>
  // Delivery a plain submit uses right now.
  delivery: Accessor<ComposerDelivery>
  // Delivery offered on Mod+Enter and the toolbar hint button; undefined hides the hint.
@@ -168,6 +168,7 @@ function ComposerStory(props: {
              alternate: () => props.alternate,
              editing: () => undefined,
              confirmEdit() {},
+              undoing: () => false,
              cancelEdit() {},
              editFirst: () => false,
            }
@@ -16,6 +16,7 @@ export function Composer(props: {
  class?: string
  model: ComposerModel
  borderUnderlay?: boolean
+  readOnly?: boolean
  suggestionBoundary?: () => HTMLElement | undefined
 }) {
  const dialog = useDialog()
@@ -27,6 +28,7 @@ export function Composer(props: {
      <ComposerEditor
        controller={props.model}
        borderUnderlay={props.borderUnderlay}
+        readOnly={props.readOnly}
        class={props.class}
        modelControlsVisible={!props.model.model.loading}
        attachKeybind={command.keybindParts("file.attach")}
@@ -371,6 +371,7 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
        onSubmit: (submitOptions) => {
          if (!available()) return
          const queue = options?.queue
+          if (queue?.undoing()) return
          // Confirming an edit re-admits the queued prompt instead of sending
          // the composer value as a new prompt. Enter keeps it queued in
          // place; the alternate action sends it as a steer.
@@ -86,6 +86,7 @@ export function createHomeSessionsController(home: HomeController) {
      sessions: indexedSessions,
      projectDirectories,
      projects: home.project.list,
+      resolveProject: (session) => home.server.focusedContext()?.projects.forSession(session),
    }),
  )
  const records = createMemo(() => allRecords().slice(0, HOME_SESSION_LIMIT))
@@ -291,6 +292,7 @@ export function createHomeSessionsController(home: HomeController) {
          sessions: () => [result],
          projectDirectories,
          projects: home.project.list,
+          resolveProject: ctx.projects.forSession,
        })[0]
      },
      create: home.project.openNewSession,
@@ -18,6 +18,7 @@ export function buildHomeSessionRecords(input: {
  sessions: () => SessionInfo[]
  projectDirectories: () => string[] | undefined
  projects: () => LocalProject[]
+  resolveProject?: (session: SessionInfo) => LocalProject | undefined
 }) {
  const selected = input.projectDirectories()
  const directories = selected ? new Set(selected.map(pathKey)) : undefined
@@ -27,11 +28,12 @@ export function buildHomeSessionRecords(input: {
  return [...new Map(sessions.map((session) => [session.id, session] as const)).values()]
    .sort(compareSessionTime)
    .map((session) => {
-      const project = homeProjectForSession(session, input.projects()) ?? {
-        id: session.projectID,
-        worktree: session.location.directory,
-        expanded: false,
-      }
+      const project = input.resolveProject?.(session) ??
+        homeProjectForSession(session, input.projects()) ?? {
+          id: session.projectID,
+          worktree: session.location.directory,
+          expanded: false,
+        }
      return { session, project, projectName: displayName(project) }
    })
 }
@@ -874,6 +874,9 @@ export const dict = {
  "session.queue.send": "Send",
  "session.queue.steerTooltip": "Send without interrupting",
  "session.queue.remove": "Remove",
+  "session.queue.undo": "Undo",
+  "session.queue.undoShell": "Leave shell mode before undoing a queued prompt",
+  "session.queue.undoUnavailable": "Edit this prompt in the queue to preserve its file context",
  "session.queue.reorder": "Reorder queued prompt",
  "session.queue.attachments.one": "{{count}} attachment",
  "session.queue.attachments.other": "{{count}} attachments",
@@ -1439,6 +1442,15 @@ export const dict = {
  "settings.providers.section.connected": "Connected providers",
  "settings.providers.connected.empty": "No connected providers",
  "settings.providers.connected.environmentDescription": "Connected from your environment variables",
+  "settings.providers.account.manage": "Manage {{provider}} accounts",
+  "settings.providers.account.group": "Accounts",
+  "settings.providers.account.add": "Add account",
+  "settings.providers.account.remove": "Remove account…",
+  "settings.providers.account.active": "Active",
+  "settings.providers.account.switched.title": "{{provider}} account switched",
+  "settings.providers.account.switched.description": "Now using {{account}}.",
+  "settings.providers.account.removed.title": "{{account}} removed",
+  "settings.providers.account.removed.description": "{{provider}} will no longer use this account.",
  "settings.providers.console.available.one": "{{count}} provider available",
  "settings.providers.console.available.other": "{{count}} providers available",
  "settings.providers.section.popular": "Popular providers",
@@ -25,6 +25,8 @@ export type BrowserPaneEvent =
 export type BrowserPaneRegistration = {
  setLayout(layout?: BrowserPaneLayout): void
  command(command: BrowserPaneCommand): Promise<void>
+  /** Captures the shown page, or resolves null when nothing is on screen. */
+  capture(tabID: Browser.TabID): Promise<Blob | null>
  close(): void
 }

@@ -18,6 +18,8 @@ import { showToast } from "@/shell/notifications/toast"
 import { formatServerError } from "./errors"
 import { useSettings } from "@/settings/model"
 import { timelinePreset } from "@opencode/session-ui/timeline/detail"
+import type { SessionInfo } from "@opencode/client/promise"
+import { resolveProjectForSession, resolveSessionDetailsProject } from "@/shell/layout/helpers"

 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
  name: "Global",
@@ -180,6 +182,13 @@ function createServerController(
  }

  const projectsList = createMemo(() => projects.list().map(enrich))
+  const forSession = (session: SessionInfo) => {
+    const project = resolveProjectForSession(session, projectsList(), sync.data.project)
+    if (!project) return
+    return "expanded" in project ? project : { ...project, expanded: false }
+  }
+  const detailsForSession = (session: SessionInfo) =>
+    resolveSessionDetailsProject(session, projectsList(), sync.data.project)
  const recentlyClosedList = createMemo(() => {
    const known = new Set(sync.data.project.map((project) => pathKey(project.worktree)))
    return projects
@@ -200,6 +209,8 @@ function createServerController(
    projects: {
      ...projects,
      list: projectsList,
+      forSession,
+      detailsForSession,
      resolve: enrich,
      recentlyClosed: recentlyClosedList,
    },
@@ -43,6 +43,9 @@ function fixture() {
          async command(command) {
            call.commands.push(command)
          },
+          async capture() {
+            return null
+          },
          close() {
            call.closed = true
          },
@@ -11,6 +11,7 @@ import { createStore } from "solid-js/store"
 import { useLanguage } from "@/runtime/i18n/language"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useCommand } from "@/shell/commands/command"
+import type { Browser } from "@opencode/plugin-browser/rpc"
 import type { createSessionBrowser } from "./model"

 export function SessionBrowserPane(props: { browser: ReturnType<typeof createSessionBrowser>; visible: boolean }) {
@@ -30,6 +31,8 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    // A submitted navigation the browser has not reported yet; keeps the empty state hidden meanwhile.
    navigating: false,
    visible: typeof document === "undefined" || document.visibilityState === "visible",
+    // A still of the page shown in the DOM while floating content covers the hidden native view.
+    snapshot: undefined as { tabID: Browser.TabID; url: string } | undefined,
  })
  const empty = () => !address() && !state()?.loading && !store.navigating
  let surface: HTMLDivElement | undefined
@@ -37,6 +40,8 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
  let frame: number | undefined
  let layout: string | undefined
  let until = 0
+  let capturing: Browser.TabID | undefined
+  let release: ReturnType<typeof setTimeout> | undefined
  const canvas = document.createElement("canvas")
  canvas.width = canvas.height = 1
  const paint = canvas.getContext("2d", { willReadFrequently: true })
@@ -69,6 +74,45 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
      const r = el.getBoundingClientRect()
      return r.width > 0 && r.left < rect.right && r.right > rect.left && r.top < rect.bottom && r.bottom > rect.top
    })
+  const replaceSnapshot = (next?: { tabID: Browser.TabID; url: string }) => {
+    if (store.snapshot?.url) URL.revokeObjectURL(store.snapshot.url)
+    setStore("snapshot", next)
+  }
+  // Keep the page on screen as a still under the floating content. The native view
+  // stays visible until the still has decoded, so the pane never flashes blank.
+  const freeze = (tabID: Browser.TabID) => {
+    clearTimeout(release)
+    release = undefined
+    if (store.snapshot?.tabID === tabID || capturing === tabID) return
+    capturing = tabID
+    void (registration()?.capture(tabID) ?? Promise.resolve(null))
+      .catch(() => null)
+      .then(async (blob) => {
+        const url = blob ? URL.createObjectURL(blob) : ""
+        if (url) {
+          const image = new Image()
+          image.src = url
+          await image.decode().catch(() => undefined)
+        }
+        if (capturing !== tabID) {
+          if (url) URL.revokeObjectURL(url)
+          return
+        }
+        capturing = undefined
+        // A failed capture still hides the page; the pane shows its background as before.
+        replaceSnapshot({ tabID, url })
+        schedule()
+      })
+  }
+  const thaw = () => {
+    capturing = undefined
+    if (!store.snapshot || release !== undefined) return
+    // Keep the still under the native view until the view has painted again.
+    release = setTimeout(() => {
+      release = undefined
+      replaceSnapshot()
+    }, 150)
+  }
  const measure = () => {
    if (!surface) return
    const tab = state()
@@ -84,7 +128,11 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    const bottom = Math.round(rect.bottom * zoom)
    // The desktop page hides blank and loading documents itself; only hide here
    // while the pane shows its own empty or failed state over the surface.
-    const visible = props.visible && store.visible && !empty() && !failed() && !dialog.active && !covered(rect)
+    const shown = props.visible && store.visible && !empty() && !failed() && !dialog.active
+    const cover = covered(rect)
+    if (shown && cover) freeze(tab.id)
+    if (!cover) thaw()
+    const visible = shown && !(cover && store.snapshot?.tabID === tab.id)
    // The cutout exposes the app backdrop outside the rounded Review card,
    // not the browser surface inside it.
    const color = getComputedStyle(
@@ -186,6 +234,9 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
  createEventListener(document, "visibilitychange", () => setStore("visible", document.visibilityState === "visible"))
  onCleanup(() => {
    if (frame !== undefined) cancelAnimationFrame(frame)
+    clearTimeout(release)
+    capturing = undefined
+    replaceSnapshot()
  })

  return (
@@ -296,7 +347,17 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          {error()}
        </div>
      </Show>
-      <div ref={surface} class="min-h-0 flex-1 bg-v2-background-bg-base flex items-center justify-center">
+      <div ref={surface} class="relative min-h-0 flex-1 bg-v2-background-bg-base flex items-center justify-center">
+        <Show when={store.snapshot?.tabID === state()?.id && !empty() && !failed() && store.snapshot?.url}>
+          {(url) => (
+            <img
+              src={url()}
+              alt=""
+              draggable={false}
+              class="absolute inset-0 size-full pointer-events-none select-none"
+            />
+          )}
+        </Show>
        <Show when={(empty() || failed()) && !props.browser.suspended()}>
          {/* Add the 40px toolbar to the file empty state's 160px bottom padding to align their centers. */}
          <div
@@ -175,6 +175,18 @@ function SessionQueueRow(props: { queue: SessionQueueView; id: string; index: nu
                  {props.queue.working() ? language.t("session.queue.steer") : language.t("session.queue.send")}
                </Button>
              </Tooltip>
+              <Tooltip placement="top" value={language.t("session.queue.undo")}>
+                <IconButton
+                  data-action="session-queue-undo"
+                  type="button"
+                  size="small"
+                  variant="ghost-muted"
+                  icon={<Icon name="arrow-down-to-line" />}
+                  disabled={props.queue.busy()}
+                  aria-label={language.t("session.queue.undo")}
+                  onClick={() => props.queue.undo(props.id)}
+                />
+              </Tooltip>
            </Show>
            <Tooltip placement="top" value={language.t("session.queue.remove")}>
              <IconButton
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { SessionInboxInfo } from "@opencode/client/promise"
-import { queuedPromptAttachments, queuedPromptRows } from "./queue"
+import { queuedPromptAttachments, queuedPromptUndoDraft, queuedPromptRows } from "./queue"

 const queued = [
  {
@@ -104,3 +104,43 @@ describe("queuedPromptAttachments", () => {
    expect(queuedPromptAttachments(item)).toEqual([])
  })
 })
+
+describe("queuedPromptUndoDraft", () => {
+  test("keeps full text, structured mentions, and inline images", () => {
+    const item = {
+      ...queued[0],
+      payload: {
+        text: "inspect @main.ts with @build",
+        files: [
+          {
+            data: "aGk=",
+            mime: "text/plain",
+            source: { type: "uri" as const, uri: "file:///repo/main.ts" },
+            name: "main.ts",
+            mention: { start: 8, end: 16, text: "@main.ts" },
+          },
+          { data: "aGk=", mime: "image/png", source: { type: "inline" as const }, name: "shot.png" },
+        ],
+        agents: [{ name: "build", mention: { start: 22, end: 28, text: "@build" } }],
+      },
+    } satisfies SessionInboxInfo
+    expect(queuedPromptUndoDraft(item)).toMatchObject([
+      { type: "text", content: "inspect " },
+      { type: "file", content: "@main.ts", url: "data:text/plain;base64,aGk=" },
+      { type: "text", content: " with " },
+      { type: "agent", content: "@build", name: "build" },
+      { type: "image", filename: "shot.png" },
+    ])
+  })
+
+  test("does not drop hidden file context", () => {
+    const item = {
+      ...queued[0],
+      payload: {
+        text: "inspect this",
+        files: [{ data: "aGk=", mime: "text/plain", source: { type: "uri" as const, uri: "file:///repo/main.ts" } }],
+      },
+    } satisfies SessionInboxInfo
+    expect(queuedPromptUndoDraft(item)).toBeUndefined()
+  })
+})
@@ -3,10 +3,11 @@ import { createStore } from "solid-js/store"
 import { useMutation } from "@tanstack/solid-query"
 import type { SessionInboxInfo } from "@opencode/client/promise"
 import { SessionMessage } from "@opencode/schema/session-message"
+import { Skill } from "@opencode/schema/skill"
 import type { ComposerDelivery } from "@/composer/adapter"
 import type { ComposerStateTarget } from "@/composer/submission-state"
 import type { ImageAttachmentPart, PathAttachmentPart, Prompt } from "@/composer/state"
-import { clonePrompt, isAttachment, promptLength } from "@/composer/prompt-parts"
+import { appendPrompt, clonePrompt, isAttachment, promptLength } from "@/composer/prompt-parts"
 import { buildPromptRequest } from "@/composer/request"
 import { blobDataUrl, createLegacyBlobReference } from "@/runtime/persistence/drafts"
 import { readPromptPresentation } from "@/composer/comment-note"
@@ -42,6 +43,7 @@ export function createSessionQueue(input: {
    mutationFn: async (
      change:
        | { type: "reorder"; inboxIDs: string[] }
+        | { type: "undo"; item: QueuedPrompt; prompt: Prompt }
        | {
            type: "edit"
            inboxIDs: string[]
@@ -54,6 +56,16 @@ export function createSessionQueue(input: {
          },
    ) => {
      if (change.type === "reorder") return rewrite(change.inboxIDs)
+      if (change.type === "undo") {
+        await server.api.session.inbox.cancel({ sessionID: input.sessionID, inboxID: change.item.id })
+        const draft = input.draft.current()
+        const prompt = promptLength(draft)
+          ? appendPrompt(draft, change.prompt)
+          : [...change.prompt, ...draft.filter(isAttachment)]
+        input.draft.set(prompt, promptLength(prompt))
+        input.restoreFocus(promptLength(prompt))
+        return
+      }
      const replacement = await editedPromptInput(
        input.sessionID,
        location().directory,
@@ -139,6 +151,21 @@ export function createSessionQueue(input: {
    if (state.editing?.id === id) cancelEdit()
    return server.api.session.inbox.cancel({ sessionID: input.sessionID, inboxID: id }).catch(() => notify())
  }
+  const undo = (id: string) => {
+    if (mutation.isPending || state.editing) return
+    const item = queued().find((entry) => entry.id === id)
+    if (!item) return
+    if (input.draft.mode.current() !== "normal") {
+      showToast({ title: language.t("session.queue.undoShell") })
+      return
+    }
+    const prompt = queuedPromptUndoDraft(item)
+    if (!prompt) {
+      showToast({ title: language.t("session.queue.undoUnavailable") })
+      return
+    }
+    mutation.mutate({ type: "undo", item, prompt })
+  }
  const reorder = (inboxIDs: string[]) => {
    if (mutation.isPending) return Promise.resolve()
    return mutation.mutateAsync({ type: "reorder", inboxIDs }).catch(() => undefined)
@@ -226,9 +253,11 @@ export function createSessionQueue(input: {
    editFirst,
    rows,
    busy: () => mutation.isPending,
+    undoing: () => mutation.isPending && mutation.variables?.type === "undo",
    working: input.working,
    steer,
    remove,
+    undo,
    edit,
    reorder,
  }
@@ -239,7 +268,7 @@ export type SessionQueue = ReturnType<typeof createSessionQueue>
 // The slice of the queue the panel renders and drives.
 export type SessionQueueView = Pick<
  SessionQueue,
-  "rows" | "editing" | "working" | "busy" | "steer" | "remove" | "edit" | "reorder"
+  "rows" | "editing" | "working" | "busy" | "steer" | "remove" | "undo" | "edit" | "reorder"
 >

 export function queuedPromptRows(items: QueuedPrompt[], replacement?: { original: string; replacement: string }) {
@@ -249,7 +278,8 @@ export function queuedPromptRows(items: QueuedPrompt[], replacement?: { original
    .map((item) => ({
      id: item.id,
      text: queuedPromptText(item),
-      attachments: (item.payload.files?.length ?? 0) + (readPromptPresentation(item.payload.metadata)?.attachments.length ?? 0),
+      attachments:
+        (item.payload.files?.length ?? 0) + (readPromptPresentation(item.payload.metadata)?.attachments.length ?? 0),
    }))
 }

@@ -287,6 +317,88 @@ export function queuedPromptAttachments(item: QueuedPrompt): (ImageAttachmentPar
  ]
 }

+// Use the full model-visible text so comment notes and path references remain
+// in the draft. Convert mentioned files, agents, and skills back into editor
+// parts; a detached draft cannot represent non-mentioned file context.
+export function queuedPromptUndoDraft(item: QueuedPrompt): Prompt | undefined {
+  if (
+    item.payload.files?.some((file) => !isComposerAttachment(file) && !file.mention) ||
+    item.payload.agents?.some((agent) => !agent.mention) ||
+    item.payload.skills?.some((skill) => !skill.mention)
+  )
+    return
+  const text = item.payload.text
+  const references = [
+    ...(item.payload.files ?? []).flatMap((file) =>
+      file.mention
+        ? [
+            {
+              type: "file" as const,
+              content: file.mention.text,
+              start: file.mention.start,
+              end: file.mention.end,
+              path: file.name ?? file.mention.text.replace(/^@/, ""),
+              filename: file.name,
+              mime: file.mime,
+              url: `data:${file.mime};base64,${file.data}`,
+            },
+          ]
+        : [],
+    ),
+    ...(item.payload.agents ?? []).flatMap((agent) =>
+      agent.mention
+        ? [
+            {
+              type: "agent" as const,
+              content: agent.mention.text,
+              start: agent.mention.start,
+              end: agent.mention.end,
+              name: agent.name,
+            },
+          ]
+        : [],
+    ),
+    ...(item.payload.skills ?? []).flatMap((skill) =>
+      skill.mention
+        ? [
+            {
+              type: "skill" as const,
+              content: skill.mention.text,
+              start: skill.mention.start,
+              end: skill.mention.end,
+              id: Skill.ID.make(skill.id),
+              name: Skill.Name.make(skill.name),
+            },
+          ]
+        : [],
+    ),
+  ].sort((left, right) => left.start - right.start)
+  if (
+    references.some(
+      (part, index) =>
+        part.start < (references[index - 1]?.end ?? 0) || text.slice(part.start, part.end) !== part.content,
+    )
+  )
+    return
+  const parts: Prompt = references.flatMap((part, index) => {
+    const start = references[index - 1]?.end ?? 0
+    return [
+      ...(part.start > start
+        ? [{ type: "text" as const, content: text.slice(start, part.start), start, end: part.start }]
+        : []),
+      part,
+    ]
+  })
+  const start = references.at(-1)?.end ?? 0
+  return [
+    ...parts,
+    ...(text.length > start || !parts.length
+      ? [{ type: "text" as const, content: text.slice(start), start, end: text.length }]
+      : []),
+    ...queuedPromptAttachments(item).filter((part) => part.type === "image"),
+  ]
+}
+
 function isComposerAttachment(file: NonNullable<QueuedPrompt["payload"]["files"]>[number]) {
  return !file.mention && file.source.type === "inline"
 }
@@ -224,7 +224,12 @@ export function ActiveSessionComposerRegion(props: {
        <div class="relative">
          <SessionQueuePanel queue={props.model.queue} />
          <div class="relative z-10">
-            <Composer model={props.model.composer} borderUnderlay suggestionBoundary={props.suggestionBoundary} />
+            <Composer
+              model={props.model.composer}
+              borderUnderlay
+              readOnly={props.model.queue.undoing()}
+              suggestionBoundary={props.suggestionBoundary}
+            />
          </div>
        </div>
      }
@@ -14,7 +14,6 @@ import { createStore } from "solid-js/store"
 import { ResizeHandle } from "@opencode/ui/resize-handle"
 import { MessageTimeline } from "@/session/timeline/message-timeline"
 import { useServer } from "@/runtime/server/current"
-import { projectForSession } from "@/shell/layout/helpers"
 import { ComposerDropzone } from "@/composer/dropzone"
 import type { SessionModel } from "@/session/model"
 import { SESSION_PANEL_WIDTH_MIN } from "@/session/session-panel-width"
@@ -66,7 +65,7 @@ function SessionScreenContent(props: { session: SessionModel; browser: ReturnTyp
  const server = useServer()
  const detailsProject = createMemo(() => {
    const info = session.data.info()
-    return info ? projectForSession(info, server.ctx.sync.data.project) : undefined
+    return info ? server.ctx.projects.detailsForSession(info) : undefined
  })
  const isDesktop = session.isDesktop
  const btw = createSessionBtw(session)
@@ -12,7 +12,7 @@ import { useServer } from "@/runtime/server/current"
 import { ServerConnection } from "@/runtime/server/registry"
 import { useLanguage } from "@/runtime/i18n/language"
 import { usePlatform } from "@/runtime/platform/platform"
-import { displayName, errorMessage, getProjectAvatarSource, projectForSession } from "@/shell/layout/helpers"
+import { displayName, errorMessage, getProjectAvatarSource } from "@/shell/layout/helpers"
 import { getProjectAvatarVariant, useLayout, type LocalProject } from "@/shell/state/layout"
 import { tabKey, useTabs } from "@/shell/tabs/tabs"
 import { useSettingsSurface } from "@/settings/surface"
@@ -319,11 +319,8 @@ export function SessionIdentityHeader(props: { sessionID: string; session?: Sess
      : sessionTitle(props.session?.title ?? (parentID() ? undefined : info()?.title)),
  )
  const project = createMemo(() => {
+    if (props.session) return server.ctx.projects.forSession(props.session)
    const projects = server.ctx.projects.list()
-    if (props.session)
-      return (
-        projectForSession(props.session, projects) ?? projectForSession(props.session, server.ctx.sync.data.project)
-      )
    const value = directory()
    if (!value) return undefined
    const key = pathKey(value)
@@ -1,7 +1,7 @@
 import { DiffChanges } from "@opencode/ui/diff-changes"
 import { Icon } from "@opencode/ui/icon"
 import { getFilename } from "@opencode/util/path"
-import { createMemo, Show, type JSX } from "solid-js"
+import { createMemo, Show } from "solid-js"
 import { useLanguage } from "@/runtime/i18n/language"
 import type { Project } from "@/runtime/server/types"
 import { useSettings } from "@/settings/model"
@@ -16,7 +16,6 @@ export function SessionSummaryPanel(props: {
  shown?: boolean
  mobile?: boolean
  project: Project
-  avatar?: JSX.Element
  directory: string
  local: boolean
  branch?: string
@@ -44,7 +43,7 @@ export function SessionSummaryPanel(props: {
  return (
    <div data-component="session-summary-panel" data-mobile={props.mobile || undefined}>
      <div>
-        <ProjectSummaryCard project={props.project} avatar={props.avatar}>
+        <ProjectSummaryCard project={props.project}>
          <SessionWorkspaceMenu
            eligible={props.moveEligible}
            sessionID={props.sessionID}
@@ -1,16 +1,14 @@
 import { Icon } from "@opencode/ui/icon"
-import { ProjectAvatar } from "@opencode/ui/project-avatar"
-import { createUniqueId, Show, type ParentProps, type JSX } from "solid-js"
+import { createUniqueId, Show, type ParentProps } from "solid-js"
 import type { Project } from "@/runtime/server/types"
 import { useSettings } from "@/settings/model"
-import { displayName, getProjectAvatarSource } from "@/shell/layout/helpers"
-import { getProjectAvatarVariant } from "@/shell/state/layout"
+import { displayName } from "@/shell/layout/helpers"
+import { ProjectIcon } from "@/shell/layout/project-icon"
 import "./summary.css"

 export function ProjectSummaryCard(
  props: ParentProps<{
    project: Pick<Project, "name" | "worktree" | "icon"> & { id?: string }
-    avatar?: JSX.Element
  }>,
 ) {
  const settings = useSettings()
@@ -26,13 +24,7 @@ export function ProjectSummaryCard(
        aria-controls={contentID}
        onClick={() => settings.sessionSummary.setProjectExpanded(!expanded())}
      >
-        {props.avatar ?? (
-          <ProjectAvatar
-            fallback={displayName(props.project)}
-            src={getProjectAvatarSource(props.project.id, props.project.icon)}
-            variant={getProjectAvatarVariant(props.project.icon?.color)}
-          />
-        )}
+        <ProjectIcon project={props.project} />
        <span dir="auto" class="session-summary-label">
          {displayName(props.project)}
        </span>
@@ -31,7 +31,6 @@ import { getReadyMarkdown, preloadMarkdown } from "@opencode/session-ui/markdown
 import { createTimelineController, type TimelineController, type TimelineSessionSource } from "./controller"
 import { createTimelineVirtualizer } from "./virtualizer"
 import { containsDirectory, isWorkspaceDirectory } from "@/workspaces/paths"
-import { projectForSession } from "@/shell/layout/helpers"
 import { parseCommentNote, readPromptPresentation } from "@/composer/comment-note"
 import { useCommand } from "@/shell/commands/command"
 import { SessionAncestorTrail, SessionProjectMenu, SessionTitleHeader } from "../session-identity-header"
@@ -143,14 +142,14 @@ function MessageTimelineView(
    const session = props.session.data.info()
    const projects = server.ctx.sync.data.project
    return session
-      ? projectForSession(session, projects)
+      ? server.ctx.projects.detailsForSession(session)
      : projects.find((item) => containsDirectory(item.worktree, sessionDirectory()))
  })
  const workspaceSession = createMemo(() => isWorkspaceDirectory(project(), sessionDirectory()))
-  const avatarProject = createMemo(() => {
+  const headerProject = createMemo(() => {
    const session = props.session.data.info()
    if (!session) return
-    return projectForSession(session, server.ctx.projects.list()) ?? project()
+    return server.ctx.projects.forSession(session)
  })
  createEffect(() => {
    const directory = project()?.worktree
@@ -408,7 +407,7 @@ function MessageTimelineView(
              <div class="flex items-center gap-1 min-w-0 flex-1">
                <div class="flex items-center gap-0.5 min-w-0 flex-1 w-full">
                  <SessionProjectMenu
-                    project={avatarProject()}
+                    project={headerProject()}
                    directory={sessionDirectory()}
                    workspace={workspaceSession()}
                  />
@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test"
+import type { IntegrationInfo } from "@opencode/client/promise"
+import { activeProviderAccount, providerAccounts } from "./accounts"
+
+const integration = (connections: IntegrationInfo["connections"]): IntegrationInfo => ({
+  id: "openai",
+  name: "OpenAI",
+  methods: [],
+  connections,
+})
+
+describe("provider accounts", () => {
+  test("preserves the server's active-first credential order", () => {
+    const value = integration([
+      { type: "credential", id: "cred_work", label: "Work", method: "key" },
+      { type: "env", name: "OPENAI_API_KEY" },
+      { type: "credential", id: "cred_personal", label: "Personal", method: "oauth" },
+    ])
+
+    expect(providerAccounts(value)).toEqual([
+      { type: "credential", id: "cred_work", label: "Work", method: "key" },
+      { type: "credential", id: "cred_personal", label: "Personal", method: "oauth" },
+    ])
+    expect(activeProviderAccount(value)).toEqual({ type: "credential", id: "cred_work", label: "Work", method: "key" })
+  })
+
+  test("returns no active account for environment-only integrations", () => {
+    const value = integration([{ type: "env", name: "OPENAI_API_KEY" }])
+
+    expect(providerAccounts(value)).toEqual([])
+    expect(activeProviderAccount(value)).toBeUndefined()
+    expect(providerAccounts(undefined)).toEqual([])
+  })
+})
@@ -0,0 +1,11 @@
+import type { ConnectionInfo, IntegrationInfo } from "@opencode/client/promise"
+
+export type ProviderAccount = Extract<ConnectionInfo, { type: "credential" }>
+
+export function providerAccounts(integration: IntegrationInfo | undefined) {
+  return integration?.connections.filter((connection): connection is ProviderAccount => connection.type === "credential") ?? []
+}
+
+export function activeProviderAccount(integration: IntegrationInfo | undefined) {
+  return providerAccounts(integration)[0]
+}
@@ -2,6 +2,7 @@ import { Button } from "@opencode/ui/button"
 import { Badge } from "@opencode/ui/badge"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { Icon } from "@opencode/ui/icon"
+import { Menu } from "@opencode/ui/menu"
 import { OpenCodeLogo } from "@/providers/opencode-logo"
 import { showToast } from "@/shell/notifications/toast"
 import { popularProviders, useProviders } from "@/providers/catalog/providers"
@@ -16,6 +17,7 @@ import { CONSOLE_INTEGRATION, CONSOLE_PROVIDERS } from "@/providers/connect/cont
 import { DialogConnectProvider, useProviderConnectController } from "@/providers/connect/dialog"
 import { ProviderModelIcon } from "@/providers/models/provider-group"
 import { SettingsList } from "@/settings/list"
+import { activeProviderAccount, providerAccounts, type ProviderAccount } from "./accounts"
 import "@/settings/settings.css"

 type ProviderSource = "env" | "api" | "account" | "config" | "custom"
@@ -47,6 +49,7 @@ export const SettingsProviders: Component<{
    disconnecting: {} as Record<string, "removing" | "removed" | "absent" | undefined>,
    consoleExpanded: false,
    connecting: false,
+    credentialID: undefined as string | undefined,
  })
  const updateDisconnecting = (ids: string[], status: "removing" | "removed" | "absent" | undefined) =>
    setState("disconnecting", (current) => ({
@@ -190,6 +193,8 @@ export const SettingsProviders: Component<{
    return currentSource !== "env" && currentSource !== "config"
  }

+  const canManageAccounts = (item: ProviderItem) => providerAccounts(integration(item)).length > 0
+
  const note = (id: string) => PROVIDER_NOTES.find((item) => item.match(id))?.key

  const disconnect = async (item: ProviderItem, name: string) => {
@@ -230,6 +235,132 @@ export const SettingsProviders: Component<{
      })
  }

+  const refreshAccounts = async () => {
+    const location = props.directory ? { directory: props.directory } : undefined
+    data.location.integration.invalidate(location)
+    data.location.provider.invalidate(location)
+    data.location.model.invalidate(location)
+    await Promise.all([
+      data.location.integration.sync(location),
+      data.location.provider.sync(location),
+      data.location.model.sync(location),
+    ])
+  }
+
+  const accountError = (error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error)
+    showToast({ title: language.t("common.requestFailed"), description: message })
+  }
+
+  const activate = async (provider: ProviderItem, providerName: string, account: ProviderAccount) => {
+    if (activeProviderAccount(integration(provider))?.id === account.id) return
+    setState("credentialID", account.id)
+    await serverSdk.api.credential
+      .activate({ credentialID: account.id })
+      .then(refreshAccounts)
+      .then(() =>
+        showToast({
+          variant: "success",
+          icon: "circle-check",
+          title: language.t("settings.providers.account.switched.title", { provider: providerName }),
+          description: language.t("settings.providers.account.switched.description", { account: account.label }),
+        }),
+      )
+      .catch(accountError)
+      .finally(() => setState("credentialID", undefined))
+  }
+
+  const remove = async (provider: ProviderItem, providerName: string, account: ProviderAccount) => {
+    const final = providerAccounts(integration(provider)).length === 1
+    setState("credentialID", account.id)
+    await serverSdk.api.credential
+      .remove({ credentialID: account.id })
+      .then(refreshAccounts)
+      .then(() =>
+        showToast({
+          variant: "success",
+          icon: "circle-check",
+          title: language.t(
+            final ? "provider.disconnect.toast.disconnected.title" : "settings.providers.account.removed.title",
+            final ? { provider: providerName } : { account: account.label },
+          ),
+          description: language.t(
+            final
+              ? "provider.disconnect.toast.disconnected.description"
+              : "settings.providers.account.removed.description",
+            { provider: providerName },
+          ),
+        }),
+      )
+      .catch(accountError)
+      .finally(() => setState("credentialID", undefined))
+  }
+
+  function AccountMenu(menuProps: { provider: ProviderItem; name?: string }) {
+    const accounts = () => providerAccounts(integration(menuProps.provider))
+    const active = () => activeProviderAccount(integration(menuProps.provider))
+    const name = () => menuProps.name ?? menuProps.provider.name
+
+    return (
+      <Menu placement="bottom-end" gutter={6}>
+        <Menu.Trigger
+          as={Button}
+          size="normal"
+          variant="ghost-muted"
+          class="settings-provider-account-trigger"
+          aria-label={language.t("settings.providers.account.manage", { provider: name() })}
+        >
+          <span>{active()?.label}</span>
+          <Icon name="chevron-down" size="small" />
+        </Menu.Trigger>
+        <Menu.Portal>
+          <Menu.Content class="settings-provider-account-menu" onEscapeKeyDown={(event) => event.stopPropagation()}>
+            <Menu.Group>
+              <Menu.GroupLabel>{language.t("settings.providers.account.group")}</Menu.GroupLabel>
+              <Menu.RadioGroup
+                class="settings-provider-account-list"
+                value={active()?.id}
+                onChange={(credentialID) => {
+                  const account = accounts().find((item) => item.id === credentialID)
+                  if (account) void activate(menuProps.provider, name(), account)
+                }}
+              >
+                <For each={accounts()}>
+                  {(account) => (
+                    <Menu.RadioItem value={account.id} closeOnSelect disabled={state.credentialID !== undefined}>
+                      <span class="settings-provider-account-label">{account.label}</span>
+                    </Menu.RadioItem>
+                  )}
+                </For>
+              </Menu.RadioGroup>
+            </Menu.Group>
+            <Menu.Separator />
+            <Menu.Item disabled={state.credentialID !== undefined} onSelect={() => connect(menuProps.provider.id)}>
+              {language.t("settings.providers.account.add")}
+            </Menu.Item>
+            <Menu.Sub placement="left-start">
+              <Menu.SubTrigger disabled={state.credentialID !== undefined || accounts().length === 0}>
+                {language.t("settings.providers.account.remove")}
+              </Menu.SubTrigger>
+              <Menu.SubContent class="settings-provider-account-submenu">
+                <For each={accounts()}>
+                  {(account) => (
+                    <Menu.Item
+                      badge={account.id === active()?.id ? language.t("settings.providers.account.active") : undefined}
+                      onSelect={() => void remove(menuProps.provider, name(), account)}
+                    >
+                      <span class="settings-provider-account-label">{account.label}</span>
+                    </Menu.Item>
+                  )}
+                </For>
+              </Menu.SubContent>
+            </Menu.Sub>
+          </Menu.Content>
+        </Menu.Portal>
+      </Menu>
+    )
+  }
+
  return (
    <>
      <div class="settings-tab-header">
@@ -268,22 +399,27 @@ export const SettingsProviders: Component<{
                            </div>
                          </div>
                          <Show
-                            when={canDisconnect(item)}
+                            when={canManageAccounts(item)}
                            fallback={
-                              <span class="settings-provider-env-hint">
-                                {language.t("settings.providers.connected.environmentDescription")}
-                              </span>
+                              <Show
+                                when={canDisconnect(item)}
+                                fallback={
+                                  <span class="settings-provider-env-hint">
+                                    {language.t("settings.providers.connected.environmentDescription")}
+                                  </span>
+                                }
+                              >
+                                <Button
+                                  size="normal"
+                                  variant="ghost-muted"
+                                  onClick={() => void disconnect(item, item.name)}
+                                >
+                                  {language.t("common.disconnect")}
+                                </Button>
+                              </Show>
                            }
                          >
-                            <Button
-                              size="normal"
-                              variant="ghost-muted"
-                              onClick={() =>
-                                void disconnect(item, item.name)
-                              }
-                            >
-                              {language.t("common.disconnect")}
-                            </Button>
+                            <AccountMenu provider={item} />
                          </Show>
                        </div>
                      }
@@ -326,13 +462,20 @@ export const SettingsProviders: Component<{
                                </Show>
                              </div>
                            </div>
-                            <Button
-                              size="normal"
-                              variant="ghost-muted"
-                              onClick={() => void disconnect(item, language.t("provider.connect.opencode.name"))}
+                            <Show
+                              when={canManageAccounts(item)}
+                              fallback={
+                                <Button
+                                  size="normal"
+                                  variant="ghost-muted"
+                                  onClick={() => void disconnect(item, language.t("provider.connect.opencode.name"))}
+                                >
+                                  {language.t("common.disconnect")}
+                                </Button>
+                              }
                            >
-                              {language.t("common.disconnect")}
-                            </Button>
+                              <AccountMenu provider={item} name={language.t("provider.connect.opencode.name")} />
+                            </Show>
                          </div>
                          <Show when={state.consoleExpanded}>
                            <div class="settings-provider-console-list">
@@ -887,6 +887,47 @@
  opacity: 1;
 }

+.settings-provider-account-trigger {
+  min-width: 0;
+  max-width: min(240px, 45%);
+}
+
+.settings-provider-account-trigger > span {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.settings-provider-account-menu[data-component="menu-v2-content"] {
+  width: min(260px, calc(100vw - 32px));
+  overflow: visible;
+}
+
+.settings-provider-account-list {
+  max-height: min(240px, calc(var(--kb-popper-content-available-height) - 120px));
+  overflow-y: auto;
+}
+
+.settings-provider-account-submenu[data-component="menu-v2-content"] {
+  width: min(260px, calc(100vw - 32px));
+  max-height: min(360px, var(--kb-popper-content-available-height));
+  overflow-y: auto;
+}
+
+.settings-provider-account-label {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+@container settings-panel (max-width: 520px) {
+  .settings-provider-account-trigger {
+    max-width: 100%;
+  }
+}
+
 .settings-providers-view-all {
  margin-top: 20px;
  padding: 0;
@@ -11,7 +11,7 @@ import { useLayout, type LocalProject } from "@/shell/state/layout"
 import { ServerConnection } from "@/runtime/server/registry"
 import { useServerSDK } from "@/runtime/server/client"
 import { useTabs } from "@/shell/tabs/tabs"
-import { displayName, projectForSession } from "@/shell/layout/helpers"
+import { displayName, resolveProjectForSession } from "@/shell/layout/helpers"
 import { createSessionTabs } from "@/session/helpers"
 import { useSessionLayout } from "@/session/session-layout"
 import { useServer } from "@/runtime/server/current"
@@ -253,9 +253,7 @@ export function createServerSessionEntries(props: {
    })
    if (current.signal.aborted) return []
    const opened = props.opened()
-    const openedByID = new Map(opened.flatMap((project) => (project.id ? [[project.id, project] as const] : [])))
    const stored = props.stored().map((project) => ({ ...project, expanded: false }))
-    const storedByID = new Map(stored.map((project) => [project.id, project] as const))
    return Promise.all([
      props.load(search, current.signal).then(
        (result) => result.data,
@@ -271,8 +269,7 @@ export function createServerSessionEntries(props: {
      [...new Map([...exact, ...listed].map((session) => [session.id, session] as const)).values()]
        .filter((session) => !session.time.archived)
        .map((session) => {
-          const project =
-            projectForSession(session, opened, openedByID) ?? projectForSession(session, stored, storedByID)
+          const project = resolveProjectForSession(session, opened, stored)
          return {
            id: `session:${props.server}:${session.id}`,
            type: "session" as const,
@@ -50,6 +50,17 @@ export const childSessionOnPath = (sessions: SessionInfo[] | undefined, rootID:
 export const displayName = (project: { name?: string; worktree: string }) =>
  project.name || getFilename(project.worktree) || project.worktree

+type ProjectAppearance = {
+  name?: string
+  worktree: string
+  icon?: { color?: string; url?: string; override?: string }
+}
+
+function withProjectAppearance<T extends ProjectAppearance>(metadata: T, appearance?: ProjectAppearance) {
+  if (!appearance || appearance === metadata) return metadata
+  return { ...metadata, name: displayName(appearance), icon: appearance.icon }
+}
+
 export function toggleHomeProjectSelection(
  current: HomeProjectSelection | undefined,
  server: ServerConnection.Key,
@@ -97,11 +108,59 @@ export function getProjectAvatarSource(id?: string, icon?: { color?: string; url
 export function projectForSession<T extends { id?: string; worktree: string; sandboxes?: string[] }>(
  session: SessionInfo,
  projects: T[],
-  byID: Map<string, T> = new Map(projects.flatMap((project) => (project.id ? [[project.id, project] as const] : []))),
 ) {
-  const direct = byID.get(session.projectID)
-  if (direct) return direct
-  return projects.find((project) => isProjectDirectory(project, session.location.directory))
+  const matching = projects.filter((project) => project.id === session.projectID)
+  if (matching.length === 1) return matching[0]
+  if (matching.length > 1) {
+    const directory = pathKey(session.location.directory)
+    const exact =
+      matching.find((project) => pathKey(project.worktree) === directory) ??
+      matching.find((project) => project.sandboxes?.some((sandbox) => pathKey(sandbox) === directory))
+    if (exact) return exact
+    return (
+      matching
+        .filter((project) => isProjectDirectory(project, session.location.directory))
+        .sort((a, b) => b.worktree.length - a.worktree.length)[0] ?? matching.at(-1)
+    )
+  }
+  const directory = pathKey(session.location.directory)
+  const exact =
+    projects.find((project) => pathKey(project.worktree) === directory) ??
+    projects.find((project) => project.sandboxes?.some((sandbox) => pathKey(sandbox) === directory))
+  if (exact) return exact
+  return projects
+    .filter((project) => isProjectDirectory(project, session.location.directory))
+    .sort((a, b) => b.worktree.length - a.worktree.length)[0]
+}
+
+export function resolveProjectForSession<
+  T extends { id?: string; worktree: string; sandboxes?: string[] },
+  U extends { id?: string; worktree: string; sandboxes?: string[] },
+>(session: SessionInfo, opened: T[], stored: U[]) {
+  const current = projectForSession(session, opened)
+  if (current?.id === session.projectID) {
+    const unresolved = opened.find(
+      (project) => !project.id && pathKey(project.worktree) === pathKey(session.location.directory),
+    )
+    if (!unresolved) return current
+    const canonical = projectForSession(session, stored)
+    if (canonical?.id === session.projectID && pathKey(canonical.worktree) === pathKey(unresolved.worktree))
+      return unresolved
+    return current
+  }
+  const synced = projectForSession(session, stored)
+  if (synced?.id !== session.projectID) return current ?? synced
+  if (current && !current.id && pathKey(current.worktree) === pathKey(session.location.directory)) return current
+  return synced
+}
+
+export function resolveSessionDetailsProject<
+  T extends ProjectAppearance & { id?: string; sandboxes?: string[] },
+  U extends ProjectAppearance & { id?: string; sandboxes?: string[] },
+>(session: SessionInfo, opened: T[], stored: U[]) {
+  const metadata = projectForSession(session, stored)
+  if (!metadata) return
+  return withProjectAppearance(metadata, resolveProjectForSession(session, opened, stored))
 }

 export const errorMessage = (err: unknown, fallback: string) => {
@@ -4,7 +4,7 @@ import { displayName, getProjectAvatarSource } from "@/shell/layout/helpers"
 import { getProjectAvatarVariant, type LocalProject } from "@/shell/state/layout"

 type ProjectIconProps = Omit<ProjectAvatarProps, "fallback" | "src" | "variant"> & {
-  project: LocalProject
+  project: Pick<LocalProject, "id" | "name" | "worktree" | "icon">
  fallback?: string
  icon?: LocalProject["icon"]
 }
@@ -9,7 +9,7 @@ import { Menu } from "@opencode/ui/menu"
 import { useGlobal, useServerCtx } from "@/runtime/server/runtime"
 import { useLanguage } from "@/runtime/i18n/language"
 import { ServerConnection, serverName, useServers } from "@/runtime/server/registry"
-import { displayName, projectForSession } from "@/shell/layout/helpers"
+import { displayName } from "@/shell/layout/helpers"
 import { SessionTabAvatar } from "@/shell/layout/session-tab-avatar"
 import { SessionProgressIndicatorV2 } from "@opencode/session-ui/v2/session-progress-indicator-v2"
 import type { SessionInfo } from "@opencode/client/promise"
@@ -57,7 +57,7 @@ export function TabNavItem(props: {
  const project = createMemo(() => {
    const session = props.session
    if (!session) return
-    return projectForSession(session, serverCtx()?.projects.list() ?? [])
+    return serverCtx()?.projects.forSession(session)
  })
  const title = createMemo(() => {
    const session = props.session
@@ -29,7 +29,6 @@ import { MobileDrawer, MobileDrawerContent, MobileDrawerLabel, MobileDrawerTrigg
 import { sessionTabTitle } from "./tab-title"
 import { SessionTabAvatar } from "@/shell/layout/session-tab-avatar"
 import { SessionProgressIndicatorV2 } from "@opencode/session-ui/v2/session-progress-indicator-v2"
-import { projectForSession } from "@/shell/layout/helpers"
 import { useSettingsDialog } from "@/settings/command"
 import { updaterAction } from "@/shell/updates/action"
 import type { UpdaterState } from "@/shell/updates/types"
@@ -441,7 +440,7 @@ export function Titlebar(props: {
              const value = session()
              if (!tab || !value) return
              const conn = global.servers.list().find((item) => ServerConnection.key(item) === tab.server)
-              return projectForSession(value, conn ? global.ensureServerCtx(conn).projects.list() : [])
+              return conn ? global.ensureServerCtx(conn).projects.forSession(value) : undefined
            })
            const currentTitle = () => {
              const tab = currentTab()
@@ -55,7 +55,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Tagged templates: a tag applied to a template literal is called as `tag(strings, ...values)`, with the tag read
      like a callee so a member tag keeps its receiver. `strings` is an array of the cooked text with a read-only `raw`
      array of the source text; an invalid escape such as `\unicode` cooks to `undefined`. One template object per
-      site, as in JS, but it is not frozen: `strings[0] = "x"` succeeds here where JS throws.
+      site and both arrays are frozen, as in JS: `strings[0] = "x"` throws a `TypeError`.
 - [x] Regular-expression literals.
 - [x] `NaN` and `Infinity` globals.
 - [ ] BigInt literals and in-interpreter BigInt arithmetic; BigInt remains invalid at JSON-like host boundaries.
@@ -85,8 +85,9 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Array binding and assignment destructuring from strings, Maps, Sets, URLSearchParams, custom synchronous
      iterators, and synchronous generators, including stepwise elisions/rest and `IteratorClose` on early completion
      or binding/default failure.
- [ ] Object destructuring from primitives follows ToObject (`const { length } = "abc"`, `const {} = 1`); non-object
-      sources are rejected.
+- [x] Object destructuring from primitives follows ToObject: `const { length } = "abc"` is `3`, `const { toFixed } = 1`
+      finds the built-in, `const {} = 1` is a no-op, and a rest element copies a string's indexes (`{ 1: "y", 2: "z" }`).
+      Only `null` and `undefined` sources throw (`Cannot destructure null as it is null.`).
 - [x] Destructuring reads through the prototype chain like member access: `const { constructor } = error` and
      `const { slice } = values` find the inherited built-in.
 - [x] Any assignment target as a `for...in` head, like `for...of`: `for (x.y in obj)`, `for (a[i++] in obj)`, and
@@ -100,9 +101,11 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] `for`, `while`, and `do...while`.
 - [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, Headers, Uint8Arrays, built-in iterators, custom
      synchronous iterators, and confined synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
- [x] `for...in` over own keys of plain objects, arrays, strings, and tool references. `null`, `undefined`, and other
-      non-objects iterate nothing. An un-awaited promise throws rather than iterating.
- [ ] `for...in` over inherited enumerable keys (`Object.create(proto)`), and skipping keys deleted during the loop.
+- [x] `for...in` over the enumerable keys of plain objects, arrays, strings, and tool references, following the
+      prototype chain like JS (`for (k in Object.create({ a: 1 }))` visits `a`; built-in prototype methods are
+      non-enumerable so `for (k in [])` visits nothing). A key deleted before its turn is skipped and keys added during
+      the loop are not visited. `null`, `undefined`, and other non-objects iterate nothing. An un-awaited promise
+      throws rather than iterating.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
 - [x] `throw` with arbitrary values.
@@ -130,7 +133,7 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Built-in method references as callbacks, such as `values.map(Math.abs)`, `records.map(JSON.stringify)`,
      `items.forEach(console.log)`, and `Promise.resolve(-1).then(Math.abs)`. Extra callback arguments a built-in
      does not consume are ignored, like JS, and consumed arguments coerce, like JS (`"3.7".replace(/\d\.\d/,
-    Math.floor)` is `"3"`). A detached method loses its receiver, as in JS: `values.filter("abc".includes)` is a `TypeError`
+Math.floor)` is `"3"`). A detached method loses its receiver, as in JS: `values.filter("abc".includes)` is a `TypeError`
      because `includes` is called without a string `this`.
 - [x] Constructors work as callbacks with JS call semantics: `Error` types construct (`messages.map(Error)`),
      and new-requiring constructors (`Map`, `Set`, `URL`, `URLSearchParams`, `Headers`, `Promise`) throw a `TypeError`,
@@ -154,8 +157,9 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
      array, an array-like object (its `length` clamped and capped like `Array.from`), or `null`/`undefined`. A
      bound function is named `bound f`, has its remaining `length`, and is not constructible.
 - [x] `JSON.parse` revivers and `JSON.stringify` function replacers see the holder object as `this`.
- [ ] The optional `thisArg` of iteration methods (`map`, `forEach`, `Map.prototype.forEach`, `Array.from`, …) is
-      accepted but not yet passed as `this`; callbacks run with `this` undefined.
+- [x] The optional `thisArg` of the Array, Uint8Array, and `Array.from` callback methods and of Map, Set,
+      URLSearchParams, and Headers `forEach` is the callback's `this`: `[1, 2].forEach(function () { this.n++ }, c)`
+      increments `c.n` twice. Arrows ignore it, as in JS; `reduce`/`reduceRight` take an initial value instead.
 - [ ] User-defined constructor calls.
 - [ ] Classes and private fields.
 - [x] Functions are objects: they hold own properties (`fn.count = 1`), enumerate them, and expose read-only `name`
@@ -168,8 +172,11 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Redeclaring a function in the same scope, or alongside a `var`, is allowed: the last declaration wins.
 - [x] Generator functions have their own `prototype` (inheriting the shared generator prototype), so
      `g() instanceof g` holds. Plain functions have none, since they cannot construct.
- [ ] `GeneratorFunction.prototype`: every function, generator or not, inherits directly from `Function.prototype`,
-      and a generator whose `prototype` was replaced by a non-object still creates from the shared generator prototype.
+- [x] Generator functions inherit from `GeneratorFunction.prototype` (async ones from
+      `AsyncGeneratorFunction.prototype`), an ordinary non-callable object under `Function.prototype` whose `prototype`
+      is the shared generator prototype and vice versa (`Object.getPrototypeOf(g).prototype.constructor`). Neither is
+      a global; async non-generator functions still inherit from `Function.prototype` directly. A generator whose
+      `prototype` was replaced by a non-object creates from the shared generator prototype.
 - [x] Generator and async generator functions bind parameters (defaults, destructuring) at the call and defer only the
      body to the first `next()`, so a bad argument throws synchronously from the call site, as in JS.
 - [x] Synchronous and async generator declarations/expressions, `yield`, and `yield*`, including lazy bodies,
@@ -224,8 +231,8 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [x] Coercion helpers and template interpolation accept functions and namespaces: `String(fn)` and `${fn}` give
      `"[object Function]"` rather than the source text, `isNaN(fn)` is `true`.
 - [x] `==` and `!=` follow IsLooselyEqual: objects (including functions and tool references) compare by identity, a
-      nullish operand never coerces the other side, and a data object facing a primitive coerces through its built-in
-      primitive form (`fn == null` is `false`, `fn == fn` is `true`, `[1] == 1` and `[1, 2] == "1,2"` are `true`).
+      nullish operand never coerces the other side, and a data object facing a primitive converts through its own
+      `valueOf`/`toString` (default hint) (`fn == null` is `false`, `fn == fn` is `true`, `[1] == 1` and `[1, 2] == "1,2"` are `true`).
      `switch` matches cases with `===`, so `switch (fn) { case fn: }` selects, and `Object.is` compares any two
      values. Operators inspect only their direct operands, so `rows == null` on a large array costs the same as
      `rows === null`, and an object merely holding a function inside (`[fn] + ""`, `-[fn]`) coerces like any other
@@ -233,17 +240,36 @@ ultimate source of truth. Upstream test262 files run verbatim from `test/test262
 - [ ] Coercing a function, promise, generator, or tool reference itself: `fn + ""`, `-fn`, `fn++`, and `fn == 1`
      throw `TypeError: Binary operators require data values.` (or the unary/update form) where JavaScript would use
      the source text or `NaN`.
- [ ] ToPrimitive on program objects: operators, `Number`/`String`, `Error(message)`, `parseInt` radix, multi-argument
-      `Date` construction and `Date.UTC`, and numeric built-in arguments (`Math.max`, `at`, `indexOf` start) should call
-      the object's own `valueOf`/`toString` in spec order and surface their throws. Today they use the built-in form
-      (`NaN`, `"[object Object]"`) and ignore own methods. Date setters and one-argument `Date` construction already
-      follow ToPrimitive.
- [x] Property keys follow ToPropertyKey: `x[null]`, `x[true]`, and objects (via their built-in string form) become
-      string keys.
+- [x] ToPrimitive on program objects: `+ - * / % **`, the relational and bitwise operators, unary `+ - ~`, `++`/`--`,
+      compound assignment, `${x}`, `Number`/`String`/`isNaN`/`isFinite`, `parseInt`/`parseFloat` (text and radix),
+      `Math.*` arguments, `Error(message)`, and `Array.prototype.join`/`toString` elements call the object's own
+      `valueOf`/`toString` in spec order (both operands left then right, `+` with the default hint) and surface their
+      throws: `{ valueOf() { return 7 } } * 2` is `14`, `` `${{ toString() { return "x" } }}` `` is `"x"`, and
+      `[1, 2]` with `arr.toString = () => "x"` makes `arr + ""` `"x"`. Dates keep their `Symbol.toPrimitive`
+      behavior (`date + 1` concatenates, `date - date` subtracts).
+- [x] String and Number method arguments convert through ToPrimitive in spec order, receiver first: search strings,
+      separators, fills, and replacements with the string hint, indexes, counts, digits, and radixes with the number
+      hint (`"abc".indexOf({ toString() { return "b" } })` is `1`, `(255).toString({ valueOf() { return 16 } })` is
+      `"ff"`, `String.prototype.trim.call({ toString() { return " a " } })` is `"a"`). Only consumed positions
+      convert; a RegExp pattern is used as is, and `includes`/`startsWith`/`endsWith` reject one before converting.
+- [x] `Error.prototype.toString` converts an object `name` or `message` through its own `toString` (`String(e)` with
+      `e.message = { toString() { return "m" } }` is `"Error: m"`); an uncaught error's report at the result boundary
+      still uses the built-in form.
+- [x] `Array.prototype.toString` calls `this.join`, so `arr.join = () => "j"` makes `arr + ""`, `String(arr)`, and
+      `${arr}` all `"j"`; a non-callable `join` gives `"[object Array]"`.
+- [ ] ToPrimitive elsewhere: numeric arguments of the Array and Uint8Array methods (`at`, `indexOf` start, `slice`)
+      still use the built-in form (`NaN`) and ignore own methods.
+- [x] Property keys follow ToPropertyKey: `x[null]` and `x[true]` become string keys, and a data object key
+      converts through its own `toString`/`valueOf` (string hint) exactly once per access, in reads, writes,
+      compound assignment, `++`, `delete`, `in`, object literals, and destructuring:
+      `o[{ toString() { return "id" } }] += 1` updates `o.id`. A nullish base throws before the key converts, as
+      in JS. Opaque values (functions, promises, tool references) keep their built-in string form.

 ## Promises and tools

 - [x] Tool calls start eagerly and return supervised, run-once CodeMode promises.
+- [x] Tool references have identity: `tools.x === tools.x` and `tools.ns === tools.ns`, so they work as `Map`/`Set`
+      members and `switch` cases like any other object.
 - [x] Direct `await`, repeated awaits, and recursive thenable assimilation when a promise or thenable is returned from
      a function/program.
 - [x] `Promise.resolve` and `Promise.reject`.
@@ -300,8 +326,9 @@ reject }` object.
 - [x] `Object()` and `new Object()` return `{}` for nullish arguments and pass objects through unchanged;
      primitive wrapper objects (`Object(1)`) are rejected explicitly.
 - [x] Computed property names and object spread. Any value works as a key (ToPropertyKey): strings, numbers, and the
-      two confined symbols as themselves, everything else as its string form (`o[null]` is `o["null"]`, `o[{}]` is
-      `o["[object Object]"]`), in reads, writes, literals, `in`, and destructuring.
+      two confined symbols as themselves, data objects through their own `toString` (`o[[1, 2]]` is `o["1,2"]`), and
+      everything else as its string form (`o[null]` is `o["null"]`), in reads, writes, literals, `in`, and
+      destructuring.
 - [x] `Object.keys`, `Object.values`, `Object.entries`, `Object.hasOwn`, `Object.assign`, and `Object.fromEntries`, with
      synchronous iterator support for `fromEntries`. Sources follow ToObject: strings enumerate by index, other
      primitives and wrappers contribute nothing, and `null`/`undefined` throw. `Object.assign` accepts array
@@ -319,7 +346,7 @@ reject }` object.
      `TypeError`.
 - [x] `Object.create(proto)` with an object or `null` prototype; any other prototype is a `TypeError`
      (`Object prototype may only be an Object or null`). Inherited reads, `in`, `hasOwnProperty`, and own-only
-      `Object.keys` follow the chain as in JS, but `for...in` still enumerates own keys only. A second `properties`
+      `Object.keys` follow the chain as in JS, and `for...in` enumerates inherited keys too. A second `properties`
      argument other than `undefined` throws a `TypeError`: property descriptors are not supported (there is no
      `Object.defineProperty` either).
 - [x] `Object.freeze`, `Object.seal`, and `Object.preventExtensions`, with `isFrozen`, `isSealed`, and `isExtensible`.
@@ -362,7 +389,6 @@ reject }` object.
      shares one prototype, where JavaScript gives each collection its own; `Object.getPrototypeOf` shows the
      difference.
 - [x] `length`, numeric indexing, index assignment, spread, and `for...of`.
- [x] The `thisArg` argument of `Array.from` is accepted and ignored, like JS arrows.
 - [x] `Array.prototype.toSpliced`.
 - [x] Canonical array/string index parsing: keys such as `"01"` are ordinary properties rather than aliases of index
      `1`.
@@ -375,8 +401,9 @@ reject }` object.
      `flat(1.9)`, `with(1.5, v)`, `Math.max("3", "2")`, `parseInt("11", "2")`, `(1.5).toFixed("2")`,
      `String.fromCharCode("65")`, and the Uint8Array equivalents. `join(sep)` and `JSON.parse(text)` apply ToString
      (`join(null)` is `"1null2"`, `JSON.parse(123)` is `123`). `Array.from({ length: "2" })` applies ToLength; a
-      promise source still throws with an `await` hint rather than JS's silent `[]`. A program object's own
-      `valueOf`/`toString` is not consulted yet (see ToPrimitive above).
+      promise source still throws with an `await` hint rather than JS's silent `[]`. `join`, `Math.*`, `parseInt`,
+      and the String and Number methods consult a program object's own `valueOf`/`toString`; the array methods do not
+      yet (see ToPrimitive above).

 ## Strings

@@ -393,14 +420,15 @@ reject }` object.
 - [x] Static `String.fromCharCode` and `String.fromCodePoint`.
 - [x] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` coerce like
      native JS, `split(undefined)` returns the whole string, and `includes`/`startsWith`/`endsWith` reject regular
-      expressions with a native-style `TypeError`. Opaque runtime references still reject as data errors, and
-      `repeat` still requires a finite non-negative count.
+      expressions with a native-style `TypeError`. Data objects convert through their own `toString`/`valueOf` (see
+      ToPrimitive above). Opaque runtime references still reject as data errors, and `repeat` still requires a finite
+      non-negative count.
 - [x] Native no-argument parity for `match()`, `matchAll()`, and `search()`; all behave as an empty pattern.
 - [x] `String.raw`, on a template object or any `{ raw }` object; raw strings and substitutions coerce through their own
      `toString`.
 - [x] `match`, `matchAll`, `search`, and `split` read any non-RegExp argument as a pattern string, as `new RegExp(arg)`
-      would: `"a1b".match(1)` matches `/1/`, `search(null)` looks for `"null"`, and `undefined` is the empty pattern.
-      Objects use their built-in string form until ToPrimitive lands.
+      would: `"a1b".match(1)` matches `/1/`, `search(null)` looks for `"null"`, `undefined` is the empty pattern, and
+      an object supplies its own `toString`.

 ## Numbers and Math

@@ -454,15 +482,15 @@ reject }` object.
 - [x] `getTimezoneOffset`, arithmetic, relational comparison, and `instanceof Date`.
 - [x] Date values serialize to ISO strings; invalid dates serialize to `null`.
 - [x] Local and UTC Date setters, including native argument coercion, mutation, rollover, invalid-Date recovery, and
-      `TimeClip` behavior.
+      `TimeClip` behavior. On an invalid Date every setter but `setTime` and `set(UTC)FullYear` answers `NaN` without
+      writing, so a time set inside an argument's `valueOf` survives.
 - [x] `Date.prototype.toUTCString` and its `toGMTString` alias.
 - [x] `toDateString` and `toTimeString` in the host's local timezone.
 - [x] `toLocaleString`, `toLocaleDateString`, and `toLocaleTimeString` always format as `en-US` in UTC
      (`"1/1/1970, 12:00:00 AM"`) so output does not depend on the host.
 - [x] Native one-argument Date coercion for supported values, including booleans, null, arrays, and plain objects.
- [x] Date setters and one-argument construction coerce object arguments through their own `valueOf`/`toString` and
-      surface their throws.
- [ ] Multi-argument construction and `Date.UTC` coerce object arguments the same way (see ToPrimitive above).
+- [x] Date setters, construction, and `Date.UTC` coerce object arguments through their own `valueOf`/`toString` in
+      argument order and surface their throws; only the first seven components are converted.
 - [x] Native Date loose-equality and default primitive-coercion semantics, using CodeMode's deterministic ISO string
      representation for the string primitive.
 - [x] Native `RangeError` branding for invalid `toISOString()` calls.
@@ -509,6 +537,11 @@ reject }` object.
 - [x] Map and Set values serialize to `{}` at host/JSON boundaries.
 - [x] Set composition and relation methods: `union`, `intersection`, `difference`, `symmetricDifference`, `isSubsetOf`,
      `isSupersetOf`, and `isDisjointFrom`, including supported Set-like operands.
+- [x] `WeakMap` (`get`, `set`, `has`, `delete`, `getOrInsert`, `getOrInsertComputed`) and `WeakSet` (`add`, `has`,
+      `delete`), constructed from iterables. Keys must be program objects: a primitive or tool reference throws
+      `Invalid value used as weak map key`, while `has`/`delete`/`get` with one answer `false`/`undefined`. Entries are
+      held by a host weak collection, so nothing is retained past the key's own lifetime. As in JS they have no `size`,
+      iteration, or `clear`, `structuredClone` rejects them, and they serialize to `{}` at host boundaries.

 ## URL and URI helpers

@@ -13,7 +13,7 @@ import {
  type Cursor,
  type Value,
 } from "./objects.js"
-import { typeofValue } from "./references.js"
+import { isOpaque, typeofValue } from "./references.js"

 /** IteratorClose: a consumer failure closes the iterator and wins over any close failure, except that a generator's
 * return() is a return completion, so a failing close wins over it, as after `break`. */
@@ -31,16 +31,15 @@ export const preserveConsumerError = <A, R>(
    })
  })

+export type Hint = "number" | "string" | "default"
+
 /**
 * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
- * default hint as "string", like their `Symbol.toPrimitive`.
+ * default hint as "string", like their `Symbol.toPrimitive`. Opaque values (functions, promises, generators, tool
+ * references) pass through unchanged so callers reject or describe them in their built-in form.
 */
-export const toPrimitive = <R>(
-  ctx: Interpreter<R>,
-  value: Value,
-  hint: "number" | "string" | "default",
-): Effect.Effect<Value, unknown, R> => {
-  if (!(value instanceof Obj)) return Effect.succeed(value)
+export const toPrimitive = <R>(ctx: Interpreter<R>, value: Value, hint: Hint): Effect.Effect<Value, unknown, R> => {
+  if (!(value instanceof Obj) || isOpaque(value)) return Effect.succeed(value)
  const asString = hint === "string" || (hint === "default" && value instanceof DateObj)
  const order = asString ? ["toString", "valueOf"] : ["valueOf", "toString"]
  return Effect.gen(function* () {
@@ -67,6 +66,28 @@ export const toPrimitiveString = <R>(ctx: Interpreter<R>, value: Value) =>
 export const toPrimitiveNumber = <R>(ctx: Interpreter<R>, value: Value) =>
  Effect.map(toPrimitive(ctx, value, "number"), coerceToNumber)

+/**
+ * Runs a native body on its arguments after ToPrimitive, in order, with one hint for all positions or one per
+ * position. Primitive arguments skip the Effect entirely.
+ */
+export const withPrimitives = <R>(
+  ctx: Interpreter<R>,
+  hints: Hint | ReadonlyArray<Hint>,
+  values: Array<Value>,
+  body: (primitives: Array<Value>) => Value | Effect.Effect<Value, unknown, R>,
+): Value | Effect.Effect<Value, unknown, R> => {
+  if (!values.some((value) => value instanceof Obj)) return body(values)
+  return Effect.flatMap(
+    Effect.forEach(values, (value, index) =>
+      toPrimitive(ctx, value, typeof hints === "string" ? hints : hints[index]!),
+    ),
+    (primitives) => {
+      const result = body(primitives)
+      return Effect.isEffect(result) ? result : Effect.succeed(result)
+    },
+  )
+}
+
 // The single acceptance list for callbacks: collections, sort, string replacers,
 // Array.from mappers, and promise reactions all admit exactly these callables.
 // Admission means dispatchable, not necessarily invocable: new-requiring
@@ -20,6 +20,7 @@ import {
  type Value,
 } from "./objects.js"
 import type { Interpreter } from "./interpreter.js"
+import { toPrimitiveString, withPrimitives } from "./callback.js"
 import { formatValue } from "../stdlib/console.js"

 export const normalizeError = (error: unknown): Diagnostic => {
@@ -47,7 +48,9 @@ export const normalizeError = (error: unknown): Diagnostic => {
  if (error instanceof Throw) {
    const value = error.value
    if (value instanceof ErrorObj) {
-      return value.host ? normalizeError(value.host) : { kind: "ExecutionFailure", message: errorToString(value) }
+      return value.host
+        ? normalizeError(value.host)
+        : { kind: "ExecutionFailure", message: errorToString(get(value, "name"), get(value, "message")) }
    }
    let message: string
    if (containsRuntimeReference(value)) {
@@ -112,9 +115,7 @@ export const materialize = <R>(ctx: Interpreter<R>, thrown: unknown): Value => {
 }

 /** Error.prototype.toString: `name: message`, omitting whichever side is empty. */
-const errorToString = (self: Obj): string => {
-  const name = get(self, "name")
-  const message = get(self, "message")
+const errorToString = (name: Value, message: Value): string => {
  const shownName = name === undefined ? "Error" : coerceToString(name)
  const shownMessage = message === undefined ? "" : coerceToString(message)
  if (shownMessage === "") return shownName
@@ -139,14 +140,13 @@ const constructAggregateErrorValue = <R>(
  proto: Obj,
 ): Effect.Effect<ErrorObj, unknown, R> =>
  Effect.gen(function* () {
+    const message = args[1] === undefined ? "" : yield* toPrimitiveString(ctx, args[1])
    const cursor = yield* ctx.iterate(args[0])
    if (cursor === undefined) throw typeError("new AggregateError(...) expects a synchronous iterable of errors.")
    const errors: Array<Value> = []
    while (true) {
      const step = yield* cursor.next
-      if (step.done) {
-        return createAggregateErrorValue(ctx, errors, args[1] === undefined ? "" : coerceToString(args[1]), proto)
-      }
+      if (step.done) return createAggregateErrorValue(ctx, errors, message, proto)
      errors.push(step.value)
    }
  })
@@ -160,7 +160,9 @@ export const errorGlobal = <R>(type: ErrorType, ctx: Interpreter<R>) => {
    const created =
      type === "AggregateError"
        ? constructAggregateErrorValue(ctx, args, proto)
-        : Effect.sync(() => createErrorValue(proto, args[0] === undefined ? undefined : coerceToString(args[0])))
+        : Effect.map(args[0] === undefined ? Effect.undefined : toPrimitiveString(ctx, args[0]), (message) =>
+            createErrorValue(proto, message),
+          )
    // ES2022 `new Error(message, { cause })`: installed only when the options object has the property at all.
    const options = args[type === "AggregateError" ? 2 : 1]
    if (!(options instanceof Obj) || !has(options, "cause")) return created
@@ -177,7 +179,16 @@ export const errorGlobal = <R>(type: ErrorType, ctx: Interpreter<R>) => {
  })
  if (type === "Error") {
    methods(builtins, prototype, [
-      ["toString", 0, (thisValue) => errorToString(receiver(Obj, thisValue, "Error.prototype.toString"))],
+      [
+        "toString",
+        0,
+        (thisValue) => {
+          const self = receiver(Obj, thisValue, "Error.prototype.toString")
+          return withPrimitives(ctx, "string", [get(self, "name"), get(self, "message")], ([name, message]) =>
+            errorToString(name, message),
+          )
+        },
+      ],
    ])
    methods(builtins, ctor, [["isError", 1, (_, args) => args[0] instanceof ErrorObj]])
    return ctor
@@ -2,7 +2,7 @@ import { Effect } from "effect"
 import { Arr, Callable, coerceToInteger, coerceToString, get, Obj, type Value } from "./objects.js"
 import { arrayGlobal } from "../stdlib/array.js"
 import { textDecoderGlobal, textEncoderGlobal, uint8ArrayGlobal } from "../stdlib/bytes.js"
-import { mapGlobal, setGlobal } from "../stdlib/collections.js"
+import { mapGlobal, setGlobal, weakMapGlobal, weakSetGlobal } from "../stdlib/collections.js"
 import { consoleGlobal } from "../stdlib/console.js"
 import { dateGlobal } from "../stdlib/date.js"
 import { jsonGlobal } from "../stdlib/json.js"
@@ -111,6 +111,8 @@ const table: Record<string, Factory> = {
  RegExp: (ctx) => regexpGlobal(ctx),
  Map: (ctx) => mapGlobal(ctx),
  Set: (ctx) => setGlobal(ctx),
+  WeakMap: (ctx) => weakMapGlobal(ctx),
+  WeakSet: (ctx) => weakSetGlobal(ctx),
  URL: (ctx) => urlGlobal(ctx),
  URLSearchParams: (ctx) => urlSearchParamsGlobal(ctx),
  Headers: (ctx) => headersGlobal(ctx),
@@ -79,7 +79,8 @@ import {
  has,
  hidden,
  hasPrototype,
-  keys,
+  ownKeys,
+  enumerable,
  Native,
  parseArrayIndex,
  Arguments,
@@ -95,14 +96,38 @@ import {
  coerceToString,
  type Value,
 } from "./objects.js"
-import { preserveConsumerError } from "./callback.js"
+import { type Hint, preserveConsumerError, toPrimitive } from "./callback.js"
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js"
 import { describeValue, isOpaque, rejectCircularInsertion, typeofValue } from "./references.js"
 import { ScopeStack } from "./scope.js"
 import { constructRegExp } from "../stdlib/regexp.js"
-import { enumerableSource } from "../stdlib/object.js"
+import { enumerableSource, restrict } from "../stdlib/object.js"
 import { compoundOperators } from "../stdlib/value.js"

+/** The binary operators that convert object operands through ToPrimitive before acting on primitives. */
+const primitiveOperators = new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "**",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "&",
+  "|",
+  "^",
+  "<<",
+  ">>",
+  ">>>",
+])
+
+/** ToPropertyKey on a primitive (or an opaque value, which keeps its built-in string form). */
+const propertyKey = (value: Value): PropertyKey =>
+  typeof value === "string" || typeof value === "number" || typeof value === "symbol" ? value : coerceToString(value)
+
 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
 const loopExit = (result: StatementResult, labels: ReadonlySet<string> | undefined): StatementResult | undefined => {
@@ -482,7 +507,7 @@ class Frame<R> {
  ): Fn {
    const builtins = this.ctx.builtins
    const fn = new Fn(
-      builtins.Function,
+      node.generator ? (node.async ? builtins.AsyncGeneratorFunction : builtins.GeneratorFunction) : builtins.Function,
      name,
      node.params,
      node.body,
@@ -931,10 +956,24 @@ class Frame<R> {
  }

  // for...in over null/undefined iterates nothing, like JS.
+  // EnumerateObjectProperties: own keys, then each prototype's, visiting a shadowed key once.
  private enumerableKeys(value: Value, node: AstNode): Array<string> {
    if (value instanceof ToolReference) return [...this.ctx.tools.keys(value.path)]
    if (value === null || value === undefined) return []
-    return keys(enumerableSource(this.ctx, "for...in", value, node))
+    const seen = new Set<string>()
+    const result: Array<string> = []
+    for (
+      let current: Obj | null = enumerableSource(this.ctx, "for...in", value, node);
+      current !== null;
+      current = current.proto
+    ) {
+      for (const key of ownKeys(current)) {
+        if (typeof key !== "string" || seen.has(key)) continue
+        seen.add(key)
+        if (enumerable(current, key)) result.push(key)
+      }
+    }
+    return result
  }

  private evaluateForInStatement(
@@ -958,6 +997,8 @@ class Frame<R> {
      const assignment = left.type === "VariableDeclaration" ? undefined : left

      for (const key of keys) {
+        // A key deleted before its turn is skipped, as in JS.
+        if (right instanceof Obj && !has(right, key)) continue
        const result = yield* Effect.gen(function* () {
          if (declared?.lexical) {
            self.scopes.push()
@@ -1116,18 +1157,15 @@ class Frame<R> {
      }

      if (pattern.type === "ObjectPattern") {
-        if (!(value instanceof Obj)) {
-          throw typeError(
-            `Object destructuring requires a data object or array value, received ${describeValue(value)}.`,
-            pattern,
-          )
+        if (value === null || value === undefined) {
+          throw typeError(`Cannot destructure ${describeValue(value)} as it is ${value}.`, pattern)
        }

        const consumed = new Set<PropertyKey>()
        for (const property of pattern.properties) {
          if (property.type === "RestElement") {
            const rest = new Obj(self.ctx.builtins.Object)
-            assign(rest, value, consumed)
+            assign(rest, enumerableSource(self.ctx, "Object destructuring", value, pattern), consumed)
            yield* self.declarePattern(property.argument, rest, mutable, property, initialize)
            continue
          }
@@ -1136,7 +1174,7 @@ class Frame<R> {
          consumed.add(typeof key === "symbol" ? key : String(key))
          yield* self.declarePattern(
            property.value,
-            self.readProperty(value, key, property),
+            self.destructuredProperty(value, key, property),
            mutable,
            property,
            initialize,
@@ -1175,24 +1213,21 @@ class Frame<R> {
      }

      if (pattern.type === "ObjectPattern") {
-        if (!(value instanceof Obj)) {
-          throw invalidData(
-            `Object destructuring requires a data object or array value, received ${describeValue(value)}.`,
-            pattern,
-          )
+        if (value === null || value === undefined) {
+          throw typeError(`Cannot destructure ${describeValue(value)} as it is ${value}.`, pattern)
        }

        const consumed = new Set<PropertyKey>()
        for (const property of pattern.properties) {
          if (property.type === "RestElement") {
            const rest = new Obj(self.ctx.builtins.Object)
-            assign(rest, value, consumed)
+            assign(rest, enumerableSource(self.ctx, "Object destructuring", value, pattern), consumed)
            yield* self.assignPattern(property.argument, rest, property)
            continue
          }
          const key = yield* self.destructuringPropertyKey(property)
          consumed.add(typeof key === "symbol" ? key : String(key))
-          yield* self.assignPattern(property.value, self.readProperty(value, key, property), property)
+          yield* self.assignPattern(property.value, self.destructuredProperty(value, key, property), property)
        }
        return
      }
@@ -1263,7 +1298,7 @@ class Frame<R> {
    }
    const keyNode = property.key
    if (property.computed) {
-      return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value))
+      return Effect.flatMap(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode))
    }
    if (keyNode.type === "Identifier") return Effect.succeed(keyNode.name)
    if (keyNode.type === "Literal") return Effect.succeed(String(keyNode.value))
@@ -1368,85 +1403,105 @@ class Frame<R> {
      const lhs = yield* self.evaluateExpression(left)
      const rhs = yield* self.evaluateExpression(node.right)
      if (operator === "instanceof") return instanceofValue(lhs, rhs, node)
+      if (lhs instanceof Obj || rhs instanceof Obj) return yield* self.applyOperator(operator, lhs, rhs, node)
      return self.applyBinaryOperator(operator, lhs, rhs, node)
    })
  }

+  /** ToPrimitive for an operand: data objects run their own methods; opaque values stay for the data gates below. */
+  private toPrimitive(value: Value, hint: Hint, node: AstNode) {
+    return this.native(() => toPrimitive(this.ctx, value, hint), node)
+  }
+
+  // Arithmetic, relational, and bitwise operators convert both operands first, left then right, so a `valueOf`
+  // runs (and throws) in spec order; `+` asks for the default hint and the rest for a number.
+  private applyOperator(operator: string, lhs: Value, rhs: Value, node: AstNode): Effect.Effect<Value, unknown, R> {
+    if (!(lhs instanceof Obj || rhs instanceof Obj))
+      return Effect.succeed(this.applyBinaryOperator(operator, lhs, rhs, node))
+    // IsLooselyEqual converts only an object facing a non-nullish primitive; two objects (including tool
+    // references, which are not Obj) compare by identity.
+    const equality = operator === "==" || operator === "!="
+    // `in` checks the right operand before ToPropertyKey on the left, so a bad right side wins over a bad key.
+    if (operator === "in" && lhs instanceof Obj && !isOpaque(lhs) && rhs instanceof Obj) {
+      return Effect.map(this.toPropertyKey(lhs, node), (key) => has(rhs, key))
+    }
+    const other = lhs instanceof Obj ? rhs : lhs
+    const converts =
+      primitiveOperators.has(operator) ||
+      (equality && other !== null && other !== undefined && typeof other !== "object")
+    if (!converts) return Effect.succeed(this.applyBinaryOperator(operator, lhs, rhs, node))
+    const hint = operator === "+" || equality ? "default" : "number"
+    const self = this
+    return Effect.gen(function* () {
+      const l = yield* self.toPrimitive(lhs, hint, node)
+      const r = yield* self.toPrimitive(rhs, hint, node)
+      return self.applyBinaryOperator(operator, l, r, node)
+    })
+  }
+
  private applyBinaryOperator(operator: string, lhs: Value, rhs: Value, node: AstNode): Value {
    if (operator === "===") return lhs === rhs
    if (operator === "!==") return lhs !== rhs
    if (operator === "==") return this.looselyEqual(lhs, rhs, node)
    if (operator === "!=") return !this.looselyEqual(lhs, rhs, node)
-    if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs)) {
-      return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : (lhs as PropertyKey))
-    }
+    if (operator === "in" && rhs instanceof Obj && !isOpaque(lhs)) return has(rhs, propertyKey(lhs))
    if (isOpaque(lhs) || isOpaque(rhs)) {
      throw invalidData("Binary operators require data values.", node)
    }
-    // Addition uses the default hint; every other operator asks for a number.
-    const hint = operator === "+" ? "default" : "number"
-    const coerceOperand = (operand: Value) => (operand instanceof Obj ? operand.toPrimitive(hint) : operand)
-    const l = coerceOperand(lhs)
-    const r = coerceOperand(rhs)
+    // Object operands were already converted by applyOperator; only primitives reach the arithmetic below.
    switch (operator) {
      case "+": {
-        const sum = (l as string) + (r as string)
+        const sum = (lhs as string) + (rhs as string)
        if (typeof sum === "string") checkStringLength(sum.length)
        return sum
      }
      case "-":
-        return (l as number) - (r as number)
+        return (lhs as number) - (rhs as number)
      case "*":
-        return (l as number) * (r as number)
+        return (lhs as number) * (rhs as number)
      case "/":
-        return (l as number) / (r as number)
+        return (lhs as number) / (rhs as number)
      case "%":
-        return (l as number) % (r as number)
+        return (lhs as number) % (rhs as number)
      case "**":
-        return (l as number) ** (r as number)
+        return (lhs as number) ** (rhs as number)
      case "<":
-        return (l as string) < (r as string)
+        return (lhs as string) < (rhs as string)
      case "<=":
-        return (l as string) <= (r as string)
+        return (lhs as string) <= (rhs as string)
      case ">":
-        return (l as string) > (r as string)
+        return (lhs as string) > (rhs as string)
      case ">=":
-        return (l as string) >= (r as string)
+        return (lhs as string) >= (rhs as string)
      case "&":
-        return (l as number) & (r as number)
+        return (lhs as number) & (rhs as number)
      case "|":
-        return (l as number) | (r as number)
+        return (lhs as number) | (rhs as number)
      case "^":
-        return (l as number) ^ (r as number)
+        return (lhs as number) ^ (rhs as number)
      case "<<":
-        return (l as number) << (r as number)
+        return (lhs as number) << (rhs as number)
      case ">>":
-        return (l as number) >> (r as number)
+        return (lhs as number) >> (rhs as number)
      case ">>>":
-        return (l as number) >>> (r as number)
+        return (lhs as number) >>> (rhs as number)
      case "in":
-        if (!(rhs instanceof Obj)) {
-          throw typeError("The 'in' operator requires a data object on the right-hand side.", node)
-        }
-        return has(rhs, coerceOperand(lhs) as PropertyKey)
+        throw typeError("The 'in' operator requires a data object on the right-hand side.", node)
      default:
        throw typeError(`Unsupported binary operator '${operator}'.`, node)
    }
  }

-  // IsLooselyEqual: objects (including functions and tool references) compare by identity, and only a
-  // data object facing a non-nullish primitive needs to coerce, so an opaque value is rejected only there.
+  // IsLooselyEqual: objects (including functions and tool references) compare by identity, and a nullish
+  // primitive never equals an object.
  private looselyEqual(lhs: Value, rhs: Value, node: AstNode): boolean {
    const lhsObject = lhs !== null && typeof lhs === "object"
    const rhsObject = rhs !== null && typeof rhs === "object"
    if (lhsObject === rhsObject) return lhsObject ? lhs === rhs : lhs == rhs
-    const object = lhsObject ? lhs : rhs
    const primitive = lhsObject ? rhs : lhs
    if (primitive === null || primitive === undefined) return false
-    if (!(object instanceof Obj) || isOpaque(object)) {
-      throw invalidData("Binary operators require data values.", node)
-    }
-    return object.toPrimitive("default") == primitive
+    // Data objects were converted by applyOperator, so only an opaque reference facing a primitive gets here.
+    throw invalidData("Binary operators require data values.", node)
  }

  private evaluateLogicalExpression(node: LogicalExpression): Effect.Effect<Value, unknown, R> {
@@ -1468,14 +1523,16 @@ class Frame<R> {
    if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(argument.name)) {
      return Effect.succeed("undefined")
    }
-    return Effect.map(this.evaluateExpression(argument), (value) => {
+    const self = this
+    return Effect.gen(function* () {
+      const value = yield* self.evaluateExpression(argument)
      if (operator === "typeof") return typeofValue(value)
      if (operator === "!") return !value
      if (operator === "void") return undefined
-      if (isOpaque(value)) {
+      const operand = yield* self.toPrimitive(value, "number", node)
+      if (isOpaque(operand)) {
        throw invalidData("Unary operators require data values.", node)
      }
-      const operand = value instanceof Obj ? value.toPrimitive("number") : value
      let result: Value
      switch (operator) {
        case "+":
@@ -1497,11 +1554,16 @@ class Frame<R> {
  private evaluateAssignmentExpression(node: AssignmentExpression): Effect.Effect<Value, unknown, R> {
    const left = node.left
    const operator = node.operator
+    // The binary operator a compound assignment applies: `+=` is `+`.
+    const binary = operator.slice(0, -1)
    const self = this
    return Effect.gen(function* () {
      if (operator === "??=" || operator === "||=" || operator === "&&=") {
        return yield* self.evaluateLogicalAssignment(node, left, operator)
      }
+      if (operator !== "=" && !compoundOperators.has(operator)) {
+        throw typeError(`Unsupported assignment operator '${operator}'.`, node)
+      }
      if (operator === "=" && (left.type === "ObjectPattern" || left.type === "ArrayPattern")) {
        const rightValue = yield* self.evaluateExpression(node.right)
        yield* self.assignPattern(left, rightValue, node)
@@ -1512,17 +1574,24 @@ class Frame<R> {
        if (operator !== "=") {
          const current = self.scopes.get(name, left)
          const rightValue = yield* self.evaluateExpression(node.right)
-          return self.scopes.set(name, self.applyCompoundAssignment(operator, current, rightValue, node), left)
+          const next =
+            current instanceof Obj || rightValue instanceof Obj
+              ? yield* self.applyOperator(binary, current, rightValue, node)
+              : self.applyBinaryOperator(binary, current, rightValue, node)
+          return self.scopes.set(name, next, left)
        }
        const rightValue = yield* self.evaluateNamed(node.right, name)
        return self.scopes.set(name, rightValue, left)
      }
      if (left.type === "MemberExpression") {
        return yield* self.modifyMember(left, (current) =>
-          Effect.map(self.evaluateExpression(node.right), (rightValue) => {
-            if (operator === "=") return { write: true, next: rightValue, result: rightValue }
-            const next = self.applyCompoundAssignment(operator, current, rightValue, node)
-            return { write: true, next, result: next }
+          Effect.flatMap(self.evaluateExpression(node.right), (rightValue) => {
+            if (operator === "=") return Effect.succeed({ write: true, next: rightValue, result: rightValue })
+            return Effect.map(self.applyOperator(binary, current, rightValue, node), (next) => ({
+              write: true,
+              next,
+              result: next,
+            }))
          }),
        )
      }
@@ -1572,8 +1641,7 @@ class Frame<R> {
      throw typeError(`Unsupported update operator '${operator}'.`, node)
    }

-    // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
-    // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
+    // CodeMode numeric coercion, not host Number(), so opaque runtime references reject clearly.
    const operand = (current: Value): number => {
      if (isOpaque(current)) {
        throw invalidData(`'${operator}' requires a data value.`, argument)
@@ -1582,21 +1650,26 @@ class Frame<R> {
    }

    if (argument.type === "Identifier") {
-      return Effect.sync(() => {
-        const name = argument.name
-        const current = operand(this.scopes.get(name, argument))
-        const next = current + increment
+      const name = argument.name
+      const current = this.scopes.get(name, argument)
+      const update = (value: Value) => {
+        const before = operand(value)
+        const next = before + increment
        this.scopes.set(name, next, argument)
-        return prefix ? next : current
-      })
+        return prefix ? next : before
+      }
+      if (!(current instanceof Obj)) return Effect.sync(() => update(current))
+      return Effect.map(this.toPrimitive(current, "number", argument), update)
    }

    if (argument.type === "MemberExpression") {
-      return this.modifyMember(argument, (current) => {
-        const value = operand(current)
-        const next = value + increment
-        return Effect.succeed({ write: true, next, result: prefix ? next : value })
-      })
+      return this.modifyMember(argument, (current) =>
+        Effect.map(this.toPrimitive(current, "number", argument), (primitive) => {
+          const value = operand(primitive)
+          const next = value + increment
+          return { write: true, next, result: prefix ? next : value }
+        }),
+      )
    }

    throw typeError("Update target must be an Identifier or MemberExpression.", argument)
@@ -1654,12 +1727,15 @@ class Frame<R> {
    })
  }

-  // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it.
+  // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it. A built-in
+  // reached through `ctx.call` runs on the root frame, so the deeper of the frame and the enclosing site counts.
  private native(body: () => Effect.Effect<Value, unknown, R>, node?: AstNode): Effect.Effect<Value, unknown, R> {
-    return Effect.provideService(
-      Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))),
-      CallSite,
-      { node, depth: this.depth },
+    return Effect.flatMap(CallSite, (site) =>
+      Effect.provideService(
+        Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))),
+        CallSite,
+        { node, depth: Math.max(this.depth, site.depth) },
+      ),
    )
  }

@@ -1996,11 +2072,11 @@ class Frame<R> {
        let key: PropertyKey

        if (property.computed) {
-          key = self.toPropertyKey(yield* self.evaluateExpression(keyNode))
+          key = yield* self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode)
        } else if (keyNode.type === "Identifier") {
          key = keyNode.name
        } else if (keyNode.type === "Literal") {
-          key = self.toPropertyKey(literal(keyNode))
+          key = propertyKey(literal(keyNode))
        } else {
          throw typeError("Unsupported object property key shape.", keyNode)
        }
@@ -2065,7 +2141,7 @@ class Frame<R> {

        if (index < expressions.length) {
          const raw = yield* self.evaluateExpression(expressions[index])
-          output += coerceToString(raw)
+          output += coerceToString(yield* self.toPrimitive(raw, "string", expressions[index]))
          checkStringLength(output.length)
        }
      }
@@ -2099,12 +2175,16 @@ class Frame<R> {
    define(
      strings,
      "raw",
-      new Arr(
-        array,
-        node.quasi.quasis.map((quasi) => quasi.value.raw),
+      restrict(
+        "freeze",
+        new Arr(
+          array,
+          node.quasi.quasis.map((quasi) => quasi.value.raw),
+        ),
      ),
      frozen,
    )
+    restrict("freeze", strings)
    this.ctx.templates.set(node, strings)
    return strings
  }
@@ -2115,13 +2195,6 @@ class Frame<R> {
    )
  }

-  private applyCompoundAssignment(operator: string, current: Value, incoming: Value, node: AstNode): Value {
-    if (!compoundOperators.has(operator)) {
-      throw typeError(`Unsupported assignment operator '${operator}'.`, node)
-    }
-    return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node)
-  }
-
  private getMemberReference(
    node: MemberExpression,
  ): Effect.Effect<MemberReference | ToolReference | { value: Value } | typeof OptionalShortCircuit, unknown, R> {
@@ -2135,37 +2208,58 @@ class Frame<R> {
      if (objectValue === OptionalShortCircuit) return OptionalShortCircuit
      if ((objectValue === null || objectValue === undefined) && node.optional) return OptionalShortCircuit

-      const key = node.computed
-        ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode))
-        : propertyNode.type === "Identifier"
+      const keyValue =
+        !node.computed && propertyNode.type === "Identifier"
          ? propertyNode.name
-          : self.toPropertyKey(yield* self.evaluateExpression(propertyNode))
-
-      if (objectValue instanceof ToolReference) {
-        if (typeof key !== "string") {
-          throw typeError("Tool paths must use string property names.", propertyNode)
-        }
-        return new ToolReference([...objectValue.path, key])
-      }
-
-      if (objectValue instanceof Obj) return { target: objectValue, key, receiver: objectValue }
-
-      // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
-      if (typeof objectValue === "string") {
-        if (key === "length") return { value: objectValue.length }
-        const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
-        if (index !== undefined) return { value: objectValue[index] }
-      }
-      const proto = primitivePrototype(self.ctx.builtins, objectValue)
-      if (proto !== undefined) return { target: proto, key, receiver: objectValue }
-
+          : yield* self.evaluateExpression(propertyNode)
+      // GetValue applies ToObject to the base before ToPropertyKey, so a nullish base throws before the key's own
+      // toString runs.
      if (objectValue === null || objectValue === undefined) {
-        throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode)
+        throw typeError(`Cannot read properties of ${objectValue} (reading '${coerceToString(keyValue)}').`, objectNode)
      }
-      throw typeError("Cannot access a property on a non-object value.", objectNode)
+      const key = yield* self.toPropertyKey(keyValue, propertyNode)
+      return self.resolveProperty(objectValue, key, objectNode, propertyNode)
    })
  }

+  private resolveProperty(
+    objectValue: Value,
+    key: PropertyKey,
+    objectNode: AstNode,
+    propertyNode: AstNode,
+  ): MemberReference | ToolReference | { value: Value } {
+    if (objectValue instanceof ToolReference) {
+      if (typeof key !== "string") {
+        throw typeError("Tool paths must use string property names.", propertyNode)
+      }
+      return objectValue.child(key)
+    }
+
+    if (objectValue instanceof Obj) return { target: objectValue, key, receiver: objectValue }
+
+    // Strings own length and indexes; every other primitive property reads through the wrapper prototype.
+    if (typeof objectValue === "string") {
+      if (key === "length") return { value: objectValue.length }
+      const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
+      if (index !== undefined) return { value: objectValue[index] }
+    }
+    const proto = primitivePrototype(this.ctx.builtins, objectValue)
+    if (proto !== undefined) return { target: proto, key, receiver: objectValue }
+
+    if (objectValue === null || objectValue === undefined) {
+      throw typeError(`Cannot read properties of ${objectValue} (reading '${String(key)}').`, objectNode)
+    }
+    throw typeError("Cannot access a property on a non-object value.", objectNode)
+  }
+
+  // One destructured property, read the way a member expression would read it (primitives use their prototype).
+  private destructuredProperty(source: Value, key: PropertyKey, node: AstNode): Value {
+    const reference = this.resolveProperty(source, key, node, node)
+    if (reference instanceof ToolReference) return reference
+    if ("value" in reference) return reference.value
+    return this.readProperty(reference.target, reference.key, node, reference.receiver)
+  }
+
  private readReference(reference: MemberReference, node: MemberExpression): Value {
    // Reject unknown promise properties so a missing await cannot hide.
    if (reference.target instanceof PromiseObj && !has(reference.target, reference.key)) {
@@ -2255,9 +2349,10 @@ class Frame<R> {
    throw typeError(`Cannot assign to read only property '${String(key)}'.`, node)
  }

-  // ToPropertyKey: anything else becomes its string form, so `counts[row.category]` works when the field is null.
-  private toPropertyKey(value: Value): PropertyKey {
-    if (typeof value === "string" || typeof value === "number" || typeof value === "symbol") return value
-    return coerceToString(value)
+  // ToPropertyKey: a data object converts through its own `toString`/`valueOf` first; anything else becomes its
+  // string form synchronously, so `counts[row.category]` works when the field is null.
+  private toPropertyKey(value: Value, node: AstNode): Effect.Effect<PropertyKey, unknown, R> {
+    if (!(value instanceof Obj)) return Effect.succeed(propertyKey(value))
+    return Effect.map(this.toPrimitive(value, "string", node), propertyKey)
  }
 }
@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { define, hidden, Native, Arr, ErrorObj, Obj, type Value } from "./objects.js"
+import { Arr, define, ErrorObj, hidden, Native, Obj, readOnly, type Value } from "./objects.js"

 export const errorTypes = [
  "Error",
@@ -27,6 +27,8 @@ const builtins = [
  "RegExp",
  "Map",
  "Set",
+  "WeakMap",
+  "WeakSet",
  "URL",
  "URLSearchParams",
  "Headers",
@@ -39,6 +41,8 @@ const builtins = [
  "AsyncIterator",
  "Generator",
  "AsyncGenerator",
+  "GeneratorFunction",
+  "AsyncGeneratorFunction",
 ] as const

 /**
@@ -77,6 +81,15 @@ export const createBuiltins = (): Builtins => {
  }
  const iterator = plain()
  const asyncIterator = plain()
+  // %GeneratorFunction.prototype% is an ordinary object linked both ways with %GeneratorPrototype%.
+  const generatorFunction = (generator: Obj) => {
+    const proto = new Obj(fn)
+    define(proto, "prototype", generator, readOnly)
+    define(generator, "constructor", proto, readOnly)
+    return proto
+  }
+  const generator = new Obj(iterator)
+  const asyncGenerator = new Obj(asyncIterator)
  return {
    Object: object,
    Function: fn,
@@ -88,6 +101,8 @@ export const createBuiltins = (): Builtins => {
    RegExp: plain(),
    Map: plain(),
    Set: plain(),
+    WeakMap: plain(),
+    WeakSet: plain(),
    URL: plain(),
    URLSearchParams: plain(),
    Headers: plain(),
@@ -98,8 +113,10 @@ export const createBuiltins = (): Builtins => {
    Iterator: iterator,
    IteratorHelper: new Obj(iterator),
    AsyncIterator: asyncIterator,
-    Generator: new Obj(iterator),
-    AsyncGenerator: new Obj(asyncIterator),
+    Generator: generator,
+    AsyncGenerator: asyncGenerator,
+    GeneratorFunction: generatorFunction(generator),
+    AsyncGeneratorFunction: generatorFunction(asyncGenerator),
    Error: error,
    TypeError: derived("TypeError"),
    RangeError: derived("RangeError"),
@@ -36,6 +36,7 @@ export const hidden: Attributes = { writable: true, enumerable: false, configura
 export const readonly: Attributes = { writable: false, enumerable: false, configurable: true }
 /** Constants such as `Math.PI` and a constructor's `prototype`. */
 export const frozen: Attributes = { writable: false, enumerable: false, configurable: false }
+export const readOnly: Attributes = { writable: false, enumerable: false, configurable: true }

 /**
 * An object owned by the program: own properties plus a prototype link. Subclasses answer, in one place, how a
@@ -356,6 +357,23 @@ export class SetObj extends Wrapper {
  }
 }

+/** Keys are program objects, so a host WeakMap gives the same lifetime rule as JavaScript without any bookkeeping. */
+export class WeakMapObj extends Wrapper {
+  override readonly tag = "WeakMap"
+  readonly map = new WeakMap<Obj, Value>()
+  override inspect() {
+    return "WeakMap { <items unknown> }"
+  }
+}
+
+export class WeakSetObj extends Wrapper {
+  override readonly tag = "WeakSet"
+  readonly set = new WeakSet<Obj>()
+  override inspect() {
+    return "WeakSet { <items unknown> }"
+  }
+}
+
 export class URLSearchParamsObj extends Wrapper {
  override readonly tag = "URLSearchParams"
  constructor(
@@ -628,7 +646,7 @@ export const ownKeys = (target: Obj): Array<string | symbol> => {
  ]
 }

-const enumerable = (target: Obj, key: string | symbol): boolean => own(target, key)?.enumerable === true
+export const enumerable = (target: Obj, key: string | symbol): boolean => own(target, key)?.enumerable === true

 /** Own enumerable keys, including the iterator symbols; what spread and `Object.assign` copy. */
 export const enumerableKeys = (target: Obj): Array<string | symbol> =>
@@ -5,6 +5,7 @@ import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpret
 import {
  define,
  get,
+  Callable,
  hidden,
  Arr,
  GeneratorObj,
@@ -18,7 +19,7 @@ import {
  type Value,
 } from "../interpreter/objects.js"
 import { describeValue, rejectCircularInsertion } from "../interpreter/references.js"
-import { applyCollectionCallback, invoke, preserveConsumerError } from "../interpreter/callback.js"
+import { applyCollectionCallback, invoke, preserveConsumerError, withPrimitives } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { compareText } from "../tool-runtime.js"

@@ -49,7 +50,7 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Va
      const values: Array<Value> = []
      for (let index = 0; index < arrayLike.length; index += 1) {
        const item = get(arrayLike.source, index)
-        values.push(apply === undefined ? item : yield* apply([item, index]))
+        values.push(apply === undefined ? item : yield* apply([item, index], args[2]))
      }
      return new Arr(proto, values)
    }
@@ -59,7 +60,9 @@ const arrayFrom = <R>(ctx: Interpreter<R>, args: Array<Value>): Effect.Effect<Va
      const step = yield* cursor.next
      if (step.done) return new Arr(proto, values)
      values.push(
-        apply === undefined ? step.value : yield* preserveConsumerError(cursor.close, apply([step.value, index])),
+        apply === undefined
+          ? step.value
+          : yield* preserveConsumerError(cursor.close, apply([step.value, index], args[2])),
      )
      index += 1
    }
@@ -146,20 +149,29 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
      "join",
      1,
      (thisValue, args) => {
-        const joined = self(thisValue, "join")
-          .items.map((item) => coerceToString(item ?? ""))
-          .join(args[0] === undefined ? "," : coerceToString(args[0]))
-        checkStringLength(joined.length)
-        return joined
+        // .map would keep holes, which Effect.forEach would then hand to the body as undefined.
+        const parts = Array.from(self(thisValue, "join").items, (item) => item ?? "")
+        return withPrimitives(
+          ctx,
+          "string",
+          [args[0] === undefined ? "," : args[0], ...parts],
+          ([separator, ...items]) => {
+            const joined = items.map(coerceToString).join(coerceToString(separator))
+            checkStringLength(joined.length)
+            return joined
+          },
+        )
      },
    ],
    [
      "toString",
      0,
-      (thisValue) =>
-        self(thisValue, "toString")
-          .items.map((item) => coerceToString(item ?? ""))
-          .join(","),
+      (thisValue) => {
+        // Spec: delegate to this.join, so an overridden join shows up in `arr + ""` and String(arr).
+        const target = self(thisValue, "toString")
+        const join = get(target, "join")
+        return join instanceof Callable ? ctx.call(join, target, []) : `[object ${target.tag}]`
+      },
    ],
    [
      "includes",
@@ -362,7 +374,7 @@ export const arrayGlobal = <R>(ctx: Interpreter<R>) => {
          const values: Array<Value> = []
          for (let index = 0; index < length; index += 1) {
            if (!(index in target.items)) continue
-            const mapped = yield* apply([target.items[index], index, target])
+            const mapped = yield* apply([target.items[index], index, target], args[1])
            if (mapped instanceof Arr) values.push(...mapped.items)
            else values.push(mapped)
          }
@@ -401,7 +413,10 @@ export const callbackMethods = <R, T extends Obj>(
    length,
    (thisValue, args) => {
      const target = self(thisValue, name)
-      return body(elements(target), target, applyCollectionCallback(ctx, args[0], `${label}.${name}`), args)
+      const call = applyCollectionCallback(ctx, args[0], `${label}.${name}`)
+      // reduce and reduceRight take an initial value where the others take a thisArg.
+      const thisArg = name.startsWith("reduce") ? undefined : args[1]
+      return body(elements(target), target, (callbackArgs) => call(callbackArgs, thisArg), args)
    },
  ]
  return [
@@ -16,6 +16,8 @@ import {
  PromiseObj,
  SetObj,
  type Value,
+  WeakMapObj,
+  WeakSetObj,
 } from "../interpreter/objects.js"
 import { describeValue, isOpaque } from "../interpreter/references.js"
 import {
@@ -188,7 +190,7 @@ export const mapGlobal = <R>(ctx: Interpreter<R>) => {
        const target = self(thisValue, "forEach")
        const apply = applyCollectionCallback(ctx, args[0], "Map.forEach")
        return Effect.gen(function* () {
-          for (const [key, item] of target.map.entries()) yield* apply([item, key, target])
+          for (const [key, item] of target.map.entries()) yield* apply([item, key, target], args[1])
          return undefined
        })
      },
@@ -386,7 +388,7 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
        const target = self(thisValue, "forEach")
        const apply = applyCollectionCallback(ctx, args[0], "Set.forEach")
        return Effect.gen(function* () {
-          for (const item of target.set.values()) yield* apply([item, item, target])
+          for (const item of target.set.values()) yield* apply([item, item, target], args[1])
          return undefined
        })
      },
@@ -402,3 +404,134 @@ export const setGlobal = <R>(ctx: Interpreter<R>) => {
  define(proto, IteratorSymbol, get(proto, "values"), hidden)
  return set
 }
+
+// CanBeHeldWeakly: only program objects; tool references are rebuilt on every access, so they could never be found again.
+const weakKey = (value: Value, label: string) => {
+  if (value instanceof Obj) return value
+  throw typeError(`Invalid value used ${label}: ${describeValue(value)} cannot be held weakly.`)
+}
+
+export const weakMapGlobal = <R>(ctx: Interpreter<R>) => {
+  const builtins = ctx.builtins
+  const proto = builtins.WeakMap
+  const weakMap = constructor<R>(builtins, proto, {
+    name: "WeakMap",
+    call: requiresNew("WeakMap"),
+    construct: (args, newTarget) => {
+      const target = new WeakMapObj(prototypeFrom(newTarget, proto))
+      if (args[0] === undefined || args[0] === null) return Effect.succeed(target)
+      return Effect.gen(function* () {
+        const cursor = yield* ctx.iterate(args[0]!)
+        if (cursor === undefined) {
+          throw typeError(
+            `new WeakMap(...) expects an iterable of [key, value] pairs, received ${describeValue(args[0])}.`,
+          )
+        }
+        while (true) {
+          const step = yield* cursor.next
+          if (step.done) return target
+          yield* preserveConsumerError(
+            cursor.close,
+            Effect.sync(() => {
+              if (!(step.value instanceof Obj)) {
+                throw typeError("new WeakMap(...) expects [key, value] pairs as entry objects.")
+              }
+              target.map.set(weakKey(getOwn(step.value, 0), "as weak map key"), getOwn(step.value, 1))
+            }),
+          )
+        }
+      })
+    },
+  })
+  const self = (thisValue: Value, name: string) => receiver(WeakMapObj, thisValue, `WeakMap.prototype.${name}`).map
+  // Lookups pass any key through: the host collection answers false for a non-object, as the spec requires.
+  const key = (value: Value) => weakKey(value, "as weak map key")
+  methods(builtins, proto, [
+    [
+      "get",
+      1,
+      (thisValue, args) => {
+        const target = self(thisValue, "get")
+        return args[0] instanceof Obj ? target.get(args[0]) : undefined
+      },
+    ],
+    ["has", 1, (thisValue, args) => self(thisValue, "has").has(args[0] as Obj)],
+    ["delete", 1, (thisValue, args) => self(thisValue, "delete").delete(args[0] as Obj)],
+    [
+      "set",
+      2,
+      (thisValue, args) => {
+        self(thisValue, "set").set(key(args[0]), args[1])
+        return thisValue
+      },
+    ],
+    [
+      "getOrInsert",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsert")
+        const k = key(args[0])
+        if (!target.has(k)) target.set(k, args[1])
+        return target.get(k)
+      },
+    ],
+    [
+      "getOrInsertComputed",
+      2,
+      (thisValue, args) => {
+        const target = self(thisValue, "getOrInsertComputed")
+        const k = key(args[0])
+        const apply = applyCollectionCallback(ctx, args[1], "WeakMap.getOrInsertComputed")
+        if (target.has(k)) return target.get(k)
+        return Effect.map(apply([k]), (value) => {
+          target.set(k, value)
+          return value
+        })
+      },
+    ],
+  ])
+  return weakMap
+}
+
+export const weakSetGlobal = <R>(ctx: Interpreter<R>) => {
+  const builtins = ctx.builtins
+  const proto = builtins.WeakSet
+  const weakSet = constructor<R>(builtins, proto, {
+    name: "WeakSet",
+    call: requiresNew("WeakSet"),
+    construct: (args, newTarget) => {
+      const target = new WeakSetObj(prototypeFrom(newTarget, proto))
+      if (args[0] === undefined || args[0] === null) return Effect.succeed(target)
+      return Effect.gen(function* () {
+        const cursor = yield* ctx.iterate(args[0]!)
+        if (cursor === undefined) {
+          throw typeError(`new WeakSet(...) expects a synchronous iterable, received ${describeValue(args[0])}.`)
+        }
+        while (true) {
+          const step = yield* cursor.next
+          if (step.done) return target
+          yield* preserveConsumerError(
+            cursor.close,
+            Effect.sync(() => {
+              target.set.add(weakKey(step.value, "in weak set"))
+            }),
+          )
+        }
+      })
+    },
+  })
+  const self = (thisValue: Value, name: string) => receiver(WeakSetObj, thisValue, `WeakSet.prototype.${name}`).set
+  methods(builtins, proto, [
+    ["has", 1, (thisValue, args) => self(thisValue, "has").has(args[0] as Obj)],
+    ["delete", 1, (thisValue, args) => self(thisValue, "delete").delete(args[0] as Obj)],
+    [
+      "add",
+      1,
+      (thisValue, args) => {
+        self(thisValue, "add").add(weakKey(args[0], "in weak set"))
+        return thisValue
+      },
+    ],
+  ])
+  return weakSet
+}
@@ -16,8 +16,11 @@ const constructDate = <R>(ctx: Interpreter<R>, args: Array<Value>, proto: Obj) =
        : new DateObj(proto, new Date(coerceToNumber(value)).getTime()),
    )
  }
-  const parts = args.map((arg) => coerceToNumber(arg))
-  return Effect.succeed(new DateObj(proto, new Date(...(parts as [number, number])).getTime()))
+  // The spec converts at most seven components, in order, so extra arguments never run program code.
+  return Effect.map(
+    Effect.forEach(args.slice(0, 7), (arg) => toPrimitiveNumber(ctx, arg), { concurrency: 1 }),
+    (parts) => new DateObj(proto, new Date(...(parts as [number, number])).getTime()),
+  )
 }

 type Getter = keyof {
@@ -79,7 +82,15 @@ export const dateGlobal = <R>(ctx: Interpreter<R>) => {
  methods(builtins, date, [
    ["now", 0, () => Date.now()],
    ["parse", 1, (_, args) => Date.parse(coerceToString(args[0]))],
-    ["UTC", 7, (_, args) => Date.UTC(...(args.map((arg) => coerceToNumber(arg)) as Parameters<typeof Date.UTC>))],
+    [
+      "UTC",
+      7,
+      (_, args) =>
+        Effect.map(
+          Effect.forEach(args.slice(0, 7), (arg) => toPrimitiveNumber(ctx, arg), { concurrency: 1 }),
+          (parts) => Date.UTC(...(parts as Parameters<typeof Date.UTC>)),
+        ),
+    ],
  ])

  const self = (thisValue: Value, name: string) => receiver(DateObj, thisValue, `Date.prototype.${name}`)
@@ -125,6 +136,8 @@ export const dateGlobal = <R>(ctx: Interpreter<R>) => {
              concurrency: 1,
            }),
            (values) => {
+              // Every setter but setTime and setFullYear leaves an invalid Date untouched and answers NaN.
+              if (Number.isNaN(hosted.getTime()) && name !== "setTime" && !name.endsWith("FullYear")) return NaN
              target.time = hosted[name](...(values as [number, number, number, number]))
              return target.time
            },
@@ -117,7 +117,7 @@ export const headersGlobal = <R>(ctx: Interpreter<R>) => {
        const target = self(thisValue, "forEach")
        const apply = applyCollectionCallback(ctx, args[0], "Headers.forEach")
        return Effect.gen(function* () {
-          for (const [key, value] of Array.from(target.headers.entries())) yield* apply([value, key, target])
+          for (const [key, value] of Array.from(target.headers.entries())) yield* apply([value, key, target], args[1])
          return undefined
        })
      },
@@ -2,7 +2,7 @@ import { Effect } from "effect"
 import { constants, type Method, methods } from "../interpreter/native.js"
 import { typeError } from "../interpreter/model.js"
 import { Obj, coerceToNumber } from "../interpreter/objects.js"
-import { preserveConsumerError } from "../interpreter/callback.js"
+import { preserveConsumerError, withPrimitives } from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"

 // Bun exposes ES2026 Math.sumPrecise before TypeScript's standard library types.
@@ -12,25 +12,27 @@ declare global {
  }
 }

-// Validate only the arguments a method consumes; like JS, extras are ignored
-// (so built-ins work as callbacks receiving (element, index, array)).
-const unary = (name: string, op: (a: number) => number): Method => [name, 1, (_, args) => op(coerceToNumber(args[0]))]
-
-const binary = (name: string, op: (a: number, b: number) => number): Method => [
-  name,
-  2,
-  (_, args) => op(coerceToNumber(args[0]), coerceToNumber(args[1])),
-]
-
-const variadic = (name: string, op: (...values: Array<number>) => number): Method => [
-  name,
-  2,
-  (_, args) => op(...args.map(coerceToNumber)),
-]
-
 export const mathGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
  const math = new Obj(builtins.Object)
+  // Convert only the arguments a method consumes; like JS, extras are ignored
+  // (so built-ins work as callbacks receiving (element, index, array)).
+  const unary = (name: string, op: (a: number) => number): Method => [
+    name,
+    1,
+    (_, args) => withPrimitives(ctx, "number", [args[0]], ([a]) => op(coerceToNumber(a))),
+  ]
+  const binary = (name: string, op: (a: number, b: number) => number): Method => [
+    name,
+    2,
+    (_, args) =>
+      withPrimitives(ctx, "number", [args[0], args[1]], ([a, b]) => op(coerceToNumber(a), coerceToNumber(b))),
+  ]
+  const variadic = (name: string, op: (...values: Array<number>) => number): Method => [
+    name,
+    2,
+    (_, args) => withPrimitives(ctx, "number", args, (values) => op(...values.map(coerceToNumber))),
+  ]
  constants(math, {
    PI: Math.PI,
    E: Math.E,
@@ -1,8 +1,9 @@
-import { constructor, constants, methods } from "../interpreter/native.js"
-import { coerceToNumber, coerceToString, type Value } from "../interpreter/objects.js"
+import { constructor, constants, type Method, methods } from "../interpreter/native.js"
+import { coerceToNumber, type Value } from "../interpreter/objects.js"
 import { rangeError, typeError } from "../interpreter/model.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
-import { coercion } from "./value.js"
+import { withPrimitives } from "../interpreter/callback.js"
+import { coerce, coercion } from "./value.js"

 export const numberGlobal = <R>(ctx: Interpreter<R>) => {
  const builtins = ctx.builtins
@@ -26,46 +27,36 @@ export const numberGlobal = <R>(ctx: Interpreter<R>) => {
    ["isFinite", 1, (_, args) => Number.isFinite(args[0])],
    ["isNaN", 1, (_, args) => Number.isNaN(args[0])],
    ["isSafeInteger", 1, (_, args) => Number.isSafeInteger(args[0])],
-    [
-      "parseInt",
-      2,
-      (_, args) => {
-        return parseInt(coerceToString(args[0]), coerceToNumber(args[1]))
-      },
-    ],
-    ["parseFloat", 1, (_, args) => parseFloat(coerceToString(args[0]))],
+    ["parseInt", 2, (_, args) => coerce(ctx, "parseInt", args)],
+    ["parseFloat", 1, (_, args) => coerce(ctx, "parseFloat", args)],
  ])

  const self = (thisValue: Value, name: string): number => {
    if (typeof thisValue === "number") return thisValue
    throw typeError(`Number.prototype.${name} requires that 'this' be a Number.`)
  }
-  const optNum = (arg: Value): number | undefined => (arg === undefined ? undefined : coerceToNumber(arg))
+  // The receiver is checked first, then the one argument converts through ToPrimitive with the number hint.
+  const formatting = (name: string, op: (value: number, digits: number | undefined) => string): Method => [
+    name,
+    1,
+    (thisValue, args) => {
+      const value = self(thisValue, name)
+      return withPrimitives(ctx, "number", [args[0]], ([digits]) =>
+        op(value, digits === undefined ? undefined : coerceToNumber(digits)),
+      )
+    },
+  ]
  methods(builtins, builtins.Number, [
-    ["toFixed", 1, (thisValue, args) => self(thisValue, "toFixed").toFixed(optNum(args[0]))],
+    formatting("toFixed", (value, digits) => value.toFixed(digits)),
    ["toLocaleString", 0, (thisValue) => self(thisValue, "toLocaleString").toLocaleString("en-US")],
-    ["toExponential", 1, (thisValue, args) => self(thisValue, "toExponential").toExponential(optNum(args[0]))],
-    [
-      "toPrecision",
-      1,
-      (thisValue, args) => {
-        const value = self(thisValue, "toPrecision")
-        const digits = optNum(args[0])
-        return digits === undefined ? value.toString() : value.toPrecision(digits)
-      },
-    ],
-    [
-      "toString",
-      1,
-      (thisValue, args) => {
-        const value = self(thisValue, "toString")
-        const radix = optNum(args[0])
-        if (radix !== undefined && (radix < 2 || radix > 36)) {
-          throw rangeError("Number.toString radix must be between 2 and 36.")
-        }
-        return value.toString(radix)
-      },
-    ],
+    formatting("toExponential", (value, digits) => value.toExponential(digits)),
+    formatting("toPrecision", (value, digits) => (digits === undefined ? value.toString() : value.toPrecision(digits))),
+    formatting("toString", (value, radix) => {
+      if (radix !== undefined && (radix < 2 || radix > 36)) {
+        throw rangeError("Number.toString radix must be between 2 and 36.")
+      }
+      return value.toString(radix)
+    }),
    ["valueOf", 0, (thisValue) => self(thisValue, "valueOf")],
  ])
  return number
@@ -104,7 +104,7 @@ const propertyKey = (value: Value): PropertyKey =>

 // SetIntegrityLevel: primitives pass through. A typed array's bytes cannot carry attributes, so JS throws after
 // already making it non-extensible.
-const restrict = (level: "freeze" | "seal" | "preventExtensions", value: Value): Value => {
+export const restrict = (level: "freeze" | "seal" | "preventExtensions", value: Value): Value => {
  if (!(value instanceof Obj)) return value
  value.extensible = false
  if (level === "preventExtensions") return value
@@ -17,7 +17,13 @@ import {
  type Value,
 } from "../interpreter/objects.js"
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js"
-import { applyCollectionCallback, isSupportedCallback, toPrimitiveString } from "../interpreter/callback.js"
+import {
+  applyCollectionCallback,
+  type Hint,
+  isSupportedCallback,
+  toPrimitiveString,
+  withPrimitives,
+} from "../interpreter/callback.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
 import { matchToValue, toHostRegex } from "./regexp.js"
 import { coercion } from "./value.js"
@@ -142,34 +148,72 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    args[index] === undefined ? undefined : num(name, args, index)
  const optStr = (name: string, args: Array<Value>, index: number): string | undefined =>
    args[index] === undefined ? undefined : str(name, args, index)
-  const rejectRegex = (name: string, args: Array<Value>): void => {
-    if (args[0] instanceof RegExpObj) {
-      throw typeError(
-        `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`,
-      )
-    }
-  }
+  // ToPrimitive in spec order: the receiver, then the arguments the method consumes, one hint per position; the
+  // rest pass through as they are.
  const simple = (
    name: string,
    length: number,
    op: (value: string, args: Array<Value>) => ReturnType<Impl>,
-  ): Method => [name, length, (thisValue, args) => op(self(thisValue, name), args)]
-  const replace = (name: "replace" | "replaceAll") =>
-    simple(name, 2, (value, args) => {
-      if (isSupportedCallback(args[1])) return replaceWithCallback(ctx, value, name, args)
-      if (typeofValue(args[1]) === "function") {
+    hints: ReadonlyArray<Hint> = [],
+  ): Method => [
+    name,
+    length,
+    (thisValue, args) => {
+      if (thisValue === null || thisValue === undefined) {
+        throw typeError(`String.prototype.${name} called on null or undefined.`)
+      }
+      return withPrimitives(
+        ctx,
+        ["string", ...hints],
+        [thisValue, ...args.slice(0, hints.length)],
+        ([value, ...primitives]) => op(coerceToString(value), [...primitives, ...args.slice(hints.length)]),
+      )
+    },
+  ]
+  // includes, startsWith, and endsWith reject a RegExp before converting their search string and position.
+  const searching = (name: string, op: (value: string, search: string, position: number | undefined) => boolean) =>
+    simple(name, 1, (value, args) => {
+      if (args[0] instanceof RegExpObj) {
        throw typeError(
-          `String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`,
+          `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`,
        )
      }
-      if (args[0] instanceof RegExpObj) {
-        const pattern = args[0].regex
-        const replacement = str(name, args, 1)
-        if (name === "replaceAll") replaceAllNeedsGlobal(pattern)
-        return name === "replace" ? value.replace(pattern, replacement) : value.replaceAll(pattern, replacement)
-      }
-      if (name === "replace") return value.replace(str(name, args, 0), str(name, args, 1))
-      return value.replaceAll(str(name, args, 0), str(name, args, 1))
+      return withPrimitives(ctx, ["string", "number"], args.slice(0, 2), (primitives) =>
+        op(value, str(name, primitives, 0), optNum(name, primitives, 1)),
+      )
+    })
+  // match, matchAll, and search read a RegExp as is and convert anything else to its pattern text.
+  const withPattern = (args: Array<Value>, op: (pattern: Value) => Value) =>
+    args[0] instanceof RegExpObj ? op(args[0]) : withPrimitives(ctx, "string", [args[0]], ([text]) => op(text))
+  const replace = (name: "replace" | "replaceAll") =>
+    simple(name, 2, (value, args) => {
+      const pattern = args[0]
+      const replacer = args[1]
+      // A RegExp pattern is used as is; a plain one converts to its search string, then a non-callable replacement.
+      return withPrimitives(
+        ctx,
+        "string",
+        [pattern instanceof RegExpObj ? undefined : pattern, isSupportedCallback(replacer) ? undefined : replacer],
+        ([search, replacement]) => {
+          if (isSupportedCallback(replacer)) {
+            return replaceWithCallback(ctx, value, name, [pattern instanceof RegExpObj ? pattern : search, replacer])
+          }
+          if (typeofValue(replacer) === "function") {
+            throw typeError(
+              `String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`,
+            )
+          }
+          const primitives = [search, replacement]
+          if (pattern instanceof RegExpObj) {
+            const regex = pattern.regex
+            const text = str(name, primitives, 1)
+            if (name === "replaceAll") replaceAllNeedsGlobal(regex)
+            return name === "replace" ? value.replace(regex, text) : value.replaceAll(regex, text)
+          }
+          if (name === "replace") return value.replace(str(name, primitives, 0), str(name, primitives, 1))
+          return value.replaceAll(str(name, primitives, 0), str(name, primitives, 1))
+        },
+      )
    })

  methods(builtins, builtins.String, [
@@ -185,107 +229,148 @@ export const stringGlobal = <R>(ctx: Interpreter<R>) => {
    simple("trimEnd", 0, (value) => value.trimEnd()),
    simple("trimRight", 0, (value) => value.trimEnd()),
    // Locale/options are deliberately unsupported; comparison uses the host default locale.
-    simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0))),
-    simple("normalize", 0, (value, args) => {
-      const form = optStr("normalize", args, 0)
-      try {
-        return value.normalize(form)
-      } catch {
-        throw rangeError(
-          `String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`,
-        )
-      }
-    }),
+    simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0)), ["string"]),
+    simple(
+      "normalize",
+      0,
+      (value, args) => {
+        const form = optStr("normalize", args, 0)
+        try {
+          return value.normalize(form)
+        } catch {
+          throw rangeError(
+            `String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`,
+          )
+        }
+      },
+      ["string"],
+    ),
    simple("split", 2, (value, args) => {
-      const wrap = (parts: Array<string>) => new Arr(builtins.Array, parts)
-      // Native: an undefined separator returns the whole string, not a split on "undefined",
-      // unless the limit truncates to zero.
-      const requestedLimit = optNum("split", args, 1)
-      if (args[0] === undefined) {
-        return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value])
-      }
-      const parts =
-        args[0] instanceof RegExpObj
-          ? value.split(args[0].regex, requestedLimit)
-          : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0)
-      checkArrayLength(parts.length)
-      return wrap(parts)
+      const separator = args[0]
+      // A RegExp separator is used as is; the limit converts before a plain separator does, as in the spec.
+      return withPrimitives(
+        ctx,
+        ["number", "string"],
+        [args[1], separator instanceof RegExpObj ? undefined : separator],
+        ([limit, pattern]) => {
+          const wrap = (parts: Array<string>) => new Arr(builtins.Array, parts)
+          // Native: an undefined separator returns the whole string, not a split on "undefined",
+          // unless the limit truncates to zero.
+          const requestedLimit = args[1] === undefined ? undefined : num("split", [pattern, limit], 1)
+          if (separator === undefined) {
+            return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value])
+          }
+          const parts =
+            separator instanceof RegExpObj
+              ? value.split(separator.regex, requestedLimit)
+              : value.split(str("split", [pattern], 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0)
+          checkArrayLength(parts.length)
+          return wrap(parts)
+        },
+      )
    }),
-    simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))),
-    simple("includes", 1, (value, args) => {
-      rejectRegex("includes", args)
-      return value.includes(str("includes", args, 0), optNum("includes", args, 1))
-    }),
-    simple("startsWith", 1, (value, args) => {
-      rejectRegex("startsWith", args)
-      return value.startsWith(str("startsWith", args, 0), optNum("startsWith", args, 1))
-    }),
-    simple("endsWith", 1, (value, args) => {
-      rejectRegex("endsWith", args)
-      return value.endsWith(str("endsWith", args, 0), optNum("endsWith", args, 1))
-    }),
-    simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1))),
-    simple("lastIndexOf", 1, (value, args) =>
-      value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1)),
+    simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1)), [
+      "number",
+      "number",
+    ]),
+    searching("includes", (value, search, position) => value.includes(search, position)),
+    searching("startsWith", (value, search, position) => value.startsWith(search, position)),
+    searching("endsWith", (value, search, position) => value.endsWith(search, position)),
+    simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1)), [
+      "string",
+      "number",
+    ]),
+    simple(
+      "lastIndexOf",
+      1,
+      (value, args) => value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1)),
+      ["string", "number"],
    ),
    replace("replace"),
    replace("replaceAll"),
-    simple("match", 1, (value, args) => {
-      const pattern = toHostRegex(args[0], "match")
-      const matched = value.match(pattern)
-      if (matched === null) return null
-      // Preserve the own `index` and `groups` properties on non-global matches.
-      if (pattern.global) return new Arr(builtins.Array, [...matched])
-      return matchToValue(builtins, matched)
-    }),
-    simple("matchAll", 1, (value, args) => {
-      const pattern = toHostRegex(args[0], "matchAll", "g")
-      if (!pattern.global) {
-        throw typeError(
-          `String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`,
-        )
-      }
-      const matches: Array<Value> = []
-      for (const match of value.matchAll(pattern)) {
-        checkArrayLength(matches.length + 1)
-        matches.push(matchToValue(builtins, match))
-      }
-      return new Arr(builtins.Array, matches)
-    }),
-    simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))),
-    simple("repeat", 1, (value, args) => {
-      const count = num("repeat", args, 0)
-      if (!Number.isFinite(count) || count < 0) {
-        throw rangeError("String.repeat expects a finite non-negative count.")
-      }
-      checkStringLength(value.length * count)
-      return value.repeat(count)
-    }),
-    simple("padStart", 1, (value, args) => {
-      const length = num("padStart", args, 0)
-      checkStringLength(length)
-      return value.padStart(length, optStr("padStart", args, 1))
-    }),
-    simple("padEnd", 1, (value, args) => {
-      const length = num("padEnd", args, 0)
-      checkStringLength(length)
-      return value.padEnd(length, optStr("padEnd", args, 1))
-    }),
-    simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)),
-    simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)),
-    simple("substring", 2, (value, args) =>
-      value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1)),
+    simple("match", 1, (value, args) =>
+      withPattern(args, (arg) => {
+        const regex = toHostRegex(arg, "match")
+        const matched = value.match(regex)
+        if (matched === null) return null
+        // Preserve the own `index` and `groups` properties on non-global matches.
+        if (regex.global) return new Arr(builtins.Array, [...matched])
+        return matchToValue(builtins, matched)
+      }),
    ),
-    simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1))),
+    simple("matchAll", 1, (value, args) =>
+      withPattern(args, (arg) => {
+        const regex = toHostRegex(arg, "matchAll", "g")
+        if (!regex.global) {
+          throw typeError(
+            `String.matchAll requires a regular expression with the global (g) flag: write /${regex.source}/${regex.flags}g, or use String.match for a single match.`,
+          )
+        }
+        const matches: Array<Value> = []
+        for (const match of value.matchAll(regex)) {
+          checkArrayLength(matches.length + 1)
+          matches.push(matchToValue(builtins, match))
+        }
+        return new Arr(builtins.Array, matches)
+      }),
+    ),
+    simple("search", 1, (value, args) => withPattern(args, (arg) => value.search(toHostRegex(arg, "search")))),
+    simple(
+      "repeat",
+      1,
+      (value, args) => {
+        const count = num("repeat", args, 0)
+        if (!Number.isFinite(count) || count < 0) {
+          throw rangeError("String.repeat expects a finite non-negative count.")
+        }
+        checkStringLength(value.length * count)
+        return value.repeat(count)
+      },
+      ["number"],
+    ),
+    simple(
+      "padStart",
+      1,
+      (value, args) => {
+        const length = num("padStart", args, 0)
+        checkStringLength(length)
+        return value.padStart(length, optStr("padStart", args, 1))
+      },
+      ["number", "string"],
+    ),
+    simple(
+      "padEnd",
+      1,
+      (value, args) => {
+        const length = num("padEnd", args, 0)
+        checkStringLength(length)
+        return value.padEnd(length, optStr("padEnd", args, 1))
+      },
+      ["number", "string"],
+    ),
+    simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0), ["number"]),
+    simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0), ["number"]),
+    simple(
+      "substring",
+      2,
+      (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1)),
+      ["number", "number"],
+    ),
+    simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1)), [
+      "number",
+      "number",
+    ]),
    simple("isWellFormed", 0, (value) => value.isWellFormed()),
    simple("toWellFormed", 0, (value) => value.toWellFormed()),
-    simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)),
-    simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)),
-    simple("concat", 1, (value, args) => {
-      const joined = value.concat(...args.map((_, index) => str("concat", args, index)))
-      checkStringLength(joined.length)
-      return joined
-    }),
+    simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0), ["number"]),
+    simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0), ["number"]),
+    simple("concat", 1, (value, args) =>
+      withPrimitives(ctx, "string", args, (parts) => {
+        const joined = value.concat(...parts.map((_, index) => str("concat", parts, index)))
+        checkStringLength(joined.length)
+        return joined
+      }),
+    ),
  ])
  define(
    builtins.String,
@@ -281,7 +281,7 @@ export const urlSearchParamsGlobal = <R>(ctx: Interpreter<R>) => {
        const target = self(thisValue, "forEach")
        const apply = applyCollectionCallback(ctx, args[0], "URLSearchParams.forEach")
        return Effect.gen(function* () {
-          for (const [key, value] of Array.from(target.params.entries())) yield* apply([value, key, target])
+          for (const [key, value] of Array.from(target.params.entries())) yield* apply([value, key, target], args[1])
          return undefined
        })
      },
@@ -1,12 +1,13 @@
 import { fn } from "../interpreter/native.js"
 import { coerceToNumber, coerceToString, type Native, type Value } from "../interpreter/objects.js"
 import type { Interpreter } from "../interpreter/interpreter.js"
+import { withPrimitives } from "../interpreter/callback.js"

 export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="])

 export type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN"

-const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>): Value => {
+export const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>) => {
  // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
  // other coercers match native through the undefined-argument path below.
  if (args.length === 0) {
@@ -14,15 +15,19 @@ const coerce = <R>(ctx: Interpreter<R>, name: Coercion, args: Array<Value>): Val
    if (name === "String") return ""
  }
  const raw = args[0]
-  if (name === "Number") return coerceToNumber(raw)
  if (name === "Boolean") return Boolean(raw)
-  if (name === "isFinite") return Number.isFinite(coerceToNumber(raw))
-  if (name === "isNaN") return Number.isNaN(coerceToNumber(raw))
  if (name === "parseInt") {
-    return parseInt(coerceToString(raw), coerceToNumber(args[1]))
+    return withPrimitives(ctx, ["string", "number"], [raw, args[1]], ([text, radix]) =>
+      parseInt(coerceToString(text), coerceToNumber(radix)),
+    )
  }
-  if (name === "parseFloat") return parseFloat(coerceToString(raw))
-  return coerceToString(raw)
+  return withPrimitives(ctx, name === "String" || name === "parseFloat" ? "string" : "number", [raw], ([value]) => {
+    if (name === "Number") return coerceToNumber(value)
+    if (name === "isFinite") return Number.isFinite(coerceToNumber(value))
+    if (name === "isNaN") return Number.isNaN(coerceToNumber(value))
+    if (name === "parseFloat") return parseFloat(coerceToString(value))
+    return coerceToString(value)
+  })
 }

 /** A global coercion function such as `Number` or `parseInt`. */
@@ -16,6 +16,8 @@ import {
  Obj,
  RegExpObj,
  SetObj,
+  WeakMapObj,
+  WeakSetObj,
  coerceToString,
  type Value,
 } from "../interpreter/objects.js"
@@ -84,7 +86,9 @@ export const structuredCloneGlobal = <R>(ctx: Interpreter<R>) =>
        if (hasOwn(value, "cause")) define(copy, "cause", clone(getOwn(value, "cause")), hidden)
        return copy
      }
-      if (isRuntimeReference(value)) throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`)
+      if (isRuntimeReference(value) || value instanceof WeakMapObj || value instanceof WeakSetObj) {
+        throw typeError(`DataCloneError: ${describeValue(value)} could not be cloned.`)
+      }
      const copy = remember(
        value instanceof Arr ? new Arr(builtins.Array, new Array(value.items.length)) : new Obj(builtins.Object),
      )
@@ -113,7 +113,16 @@ export const toolExpression = (path: string) =>
    .join("")

 export class ToolReference {
+  private readonly children = new Map<string, ToolReference>()
  constructor(readonly path: ReadonlyArray<string>) {}
+  /** One reference per path, so `tools.a === tools.a` holds like any other member read. */
+  child(key: string): ToolReference {
+    const existing = this.children.get(key)
+    if (existing !== undefined) return existing
+    const created = new ToolReference([...this.path, key])
+    this.children.set(key, created)
+    return created
+  }
 }

 // Dots in tool names are namespace separators; the last tool for a canonical path wins.
@@ -178,6 +178,25 @@ describe("call depth", () => {
    expect(Date.now() - started).toBeLessThan(2000)
  })

+  test("recursion routed through nested built-ins keeps counting depth", async () => {
+    const started = Date.now()
+    expect(
+      await value(`
+        const a = [1]
+        a.join = () => a + ""
+        const o = { toString() { return [o].map(String)[0] } }
+        const e = new Error()
+        e.message = { toString() { return String(e) } }
+        const names = []
+        for (const run of [() => String(a), () => String(o), () => String(e)]) {
+          try { run() } catch (error) { names.push(error.name) }
+        }
+        return names
+      `),
+    ).toEqual(["RangeError", "RangeError", "RangeError"])
+    expect(Date.now() - started).toBeLessThan(2000)
+  })
+
  test("uncaught overflow reports the call that overflowed", async () => {
    const failure = await error(`const f = (n) => f(n + 1); return f(0)`)
    expect(failure.kind).toBe("ExecutionFailure")
@@ -1382,7 +1382,7 @@ describe("Object.getPrototypeOf and Object.create", () => {
    expect((await error(`Object.getPrototypeOf(Symbol.iterator)`)).message).toContain("cannot convert a symbol")
  })

-  test("Object.create links the prototype: inherited reads, in, and own-only keys", async () => {
+  test("Object.create links the prototype: inherited reads, in, own-only keys, and for...in", async () => {
    expect(
      await value(`
        const p = { greet(name) { return "hi " + name }, a: 1 }
@@ -1392,7 +1392,7 @@ describe("Object.getPrototypeOf and Object.create", () => {
        for (const key in c) seen.push(key)
        return ["greet" in c, Object.keys(c), c.hasOwnProperty("a"), c.a, c.greet(c.name), Object.getPrototypeOf(c) === p, Object.getPrototypeOf(Object.create(null)), seen]
      `),
-    ).toEqual([true, ["name"], false, 1, "hi x", true, null, ["name"]])
+    ).toEqual([true, ["name"], false, 1, "hi x", true, null, ["name", "greet", "a"]])
  })

  test("Object.create rejects non-object prototypes and property descriptors", async () => {
@@ -1571,3 +1571,492 @@ describe("this, arguments, and Function.prototype.call/apply/bind", () => {
    )
  })
 })
+
+describe("ToPrimitive: operators and conversions honor program valueOf and toString", () => {
+  test("program-installed valueOf and toString on opaque values are ignored at every site", async () => {
+    expect(
+      await value(`
+        const f = () => 1
+        f.toString = () => "custom"
+        f.valueOf = () => 5
+        return [String(f), \`\${f}\`, [f].join(), new Error(f).message, isNaN(Number(f)), isNaN(Math.abs(f))]
+      `),
+    ).toEqual(["[object Function]", "[object Function]", "[object Function]", "[object Function]", true, true])
+  })
+
+  test("== converts an object facing a non-nullish primitive through its own valueOf", async () => {
+    expect(
+      await value(`
+        const one = { valueOf() { return 1 } }
+        return [one == 1, 1 == one, one == true, one == "1", one == null, one == one, one == { valueOf() { return 1 } }, [1] == 1]
+      `),
+    ).toEqual([true, true, true, true, false, true, false, true])
+    expect((await error(`(() => 1) == 1`)).message).toContain("Binary operators require data values")
+  })
+
+  test("operators, unary, template literals, and conversion functions use the object's own methods", async () => {
+    expect(
+      await value(`
+        const money = { valueOf() { return 7 } }
+        return [money * 2, money + 1, money + "", -money, +money, ~money, money < 8, money ** 2, money | 8,
+          Number(money), Math.max(money, 1), \`\${money}\`, String(money), isNaN(money), isFinite(money),
+          parseInt({ toString() { return "42px" } }), parseInt("ff", { valueOf() { return 16 } }),
+          Number.parseFloat({ toString() { return "1.5" } })]
+      `),
+    ).toEqual([
+      14,
+      8,
+      "7",
+      -7,
+      7,
+      -8,
+      true,
+      49,
+      15,
+      7,
+      7,
+      "[object Object]",
+      "[object Object]",
+      false,
+      true,
+      42,
+      255,
+      1.5,
+    ])
+  })
+
+  test("the hint picks the method: + and Number prefer valueOf, template literals and String prefer toString", async () => {
+    expect(
+      await value(`
+        const both = { valueOf() { return 1 }, toString() { return "s" } }
+        return [both + "", \`\${both}\`, String(both), both * 2, new Error(both).message, [both].join(), [both, 2] + ""]
+      `),
+    ).toEqual(["1", "s", "s", 2, "s", "s", "s,2"])
+  })
+
+  test("operands convert left then right, and a throwing valueOf surfaces as the program error", async () => {
+    expect(
+      await value(`
+        const order = []
+        const a = { valueOf() { order.push("a"); return 1 } }, b = { valueOf() { order.push("b"); return 2 } }
+        a + b; a < b; a - b
+        return order
+      `),
+    ).toEqual(["a", "b", "a", "b", "a", "b"])
+    expect(
+      await value(`
+        const bad = { valueOf() { throw new RangeError("nope") } }
+        const names = []
+        try { bad + 1 } catch (e) { names.push(e.name) }
+        try { Number(bad) } catch (e) { names.push(e.name) }
+        try { Math.abs(bad) } catch (e) { names.push(e.name) }
+        return names
+      `),
+    ).toEqual(["RangeError", "RangeError", "RangeError"])
+  })
+
+  test("arrays keep their built-in join form unless the program replaces toString", async () => {
+    expect(
+      await value(`
+        const arr = [1, 2]
+        const before = [arr + "", [] + [], [1, , 3].join("-"), [1, { toString() { return "q" } }].join("-")]
+        arr.toString = () => "x"
+        return [...before, arr + "", \`\${arr}\`, String(arr)]
+      `),
+    ).toEqual(["1,2", "", "1--3", "1-q", "x", "x", "x"])
+  })
+
+  test("update and compound assignment convert the current value", async () => {
+    expect(
+      await value(`
+        let x = { valueOf() { return 5 } }
+        const o = { n: { valueOf() { return 4 } } }
+        const after = x++
+        o.n += 1
+        o.n++
+        let s = { valueOf() { return 2 } }
+        s *= 3
+        return [after, x, o.n, s]
+      `),
+    ).toEqual([5, 6, 6, 6])
+  })
+
+  test("functions and other opaque values still reject arithmetic, and an object without a primitive form throws", async () => {
+    expect((await error(`const f = () => 1; return f + 1`)).message).toContain("Binary operators require data values")
+    expect((await error(`return -(() => 1)`)).message).toContain("Unary operators require data values")
+    const failure = await error(`return { valueOf() { return {} }, toString() { return [] } } + 1`)
+    expect(failure.message).toContain("Cannot convert object to primitive value")
+  })
+})
+
+describe("object destructuring from primitives", () => {
+  test("reads through the primitive's prototype like member access", async () => {
+    expect(
+      await value(`
+        const { length, 0: first, toUpperCase } = "abc"
+        const { toFixed } = 1.5
+        const {} = true
+        const { 0: a, ...rest } = "xyz"
+        const { ...none } = 42
+        let n
+        ;({ length: n } = "hello")
+        return [length, first, toUpperCase.call("q"), toFixed.call(2.345, 1), a, rest, none, n]
+      `),
+    ).toEqual([3, "a", "Q", "2.3", "x", { 1: "y", 2: "z" }, {}, 5])
+  })
+
+  test("only null and undefined sources throw", async () => {
+    expect((await error(`const { a } = null`)).message).toContain("Cannot destructure null as it is null")
+    expect((await error(`const {} = undefined`)).message).toContain("Cannot destructure undefined")
+    expect((await error(`let a; ({ a } = undefined)`)).message).toContain("Cannot destructure undefined")
+  })
+})
+
+describe("Date components convert through ToPrimitive", () => {
+  test("construction and Date.UTC ask each of the first seven arguments in order", async () => {
+    expect(
+      await value(`
+        const seen = []
+        const part = (n) => ({ valueOf() { seen.push(n); return n } })
+        const time = new Date(part(2024), part(1), part(2), part(3), part(4), part(5), part(6), part(99)).getTime()
+        const utc = Date.UTC(2024, { valueOf() { return 0 } }, 15)
+        return [seen, time === new Date(2024, 1, 2, 3, 4, 5, 6).getTime(), utc === Date.UTC(2024, 0, 15)]
+      `),
+    ).toEqual([[2024, 1, 2, 3, 4, 5, 6], true, true])
+    expect((await error(`new Date(2024, { valueOf() { throw new RangeError("boom") } })`)).message).toContain("boom")
+  })
+
+  test("setters on an invalid Date answer NaN without overwriting a time set during coercion", async () => {
+    expect(
+      await value(`
+        const d = new Date(NaN)
+        const result = d.setDate({ valueOf() { d.setTime(0); return 1 } })
+        const y = new Date(NaN)
+        return [Number.isNaN(result), d.getTime(), y.setFullYear(2020) === Date.UTC(2020, 0, 1) - y.getTimezoneOffset() * 60000]
+      `),
+    ).toEqual([true, 0, true])
+  })
+})
+
+describe("iteration callbacks receive thisArg", () => {
+  test("Array, Array.from, Map, Set, URLSearchParams, Headers, and Uint8Array pass it as this", async () => {
+    expect(
+      await value(`
+        const c = { n: 0 }
+        const count = function () { this.n++ }
+        ;[1, 2].forEach(count, c)
+        ;[1].map(count, c)
+        ;[1].filter(count, c)
+        ;[1].find(count, c)
+        ;[1].findIndex(count, c)
+        ;[1].findLast(count, c)
+        ;[1].findLastIndex(count, c)
+        ;[1].some(count, c)
+        ;[1].every(count, c)
+        ;[1].flatMap(count, c)
+        Array.from([1], count, c)
+        Array.from({ length: 1 }, count, c)
+        new Map([[1, 1]]).forEach(count, c)
+        new Set([1]).forEach(count, c)
+        new URLSearchParams("a=1").forEach(count, c)
+        new Headers({ a: "1" }).forEach(count, c)
+        new Uint8Array([1]).forEach(count, c)
+        return c.n
+      `),
+    ).toBe(18)
+    expect(await value(`return [1, 2].map(function (x) { return x + this.v }, { v: 10 })`)).toEqual([11, 12])
+  })
+
+  test("arrows keep their lexical this, reduce takes an initial value instead, and opaque values are only bound", async () => {
+    expect(await value(`return [1].map(() => typeof this, { v: 1 })`)).toEqual(["undefined"])
+    expect(
+      await value(`return [1, 2].reduce(function (a, b) { return a + b + (this === undefined ? 0 : 100) }, 0)`),
+    ).toBe(3)
+    expect(
+      await value(`
+        let seen
+        ;[1].forEach(function () { seen = this }, tools.nowhere)
+        return typeof seen
+      `),
+    ).toBe("function")
+  })
+})
+
+describe("computed property keys convert through the object's own toString", () => {
+  test("reads, writes, compound assignment, in, delete, literals, and destructuring share one conversion", async () => {
+    expect(
+      await value(`
+        const key = { toString() { return "id" } }
+        const o = {}
+        o[key] = 1
+        o[key] += 1
+        const literal = { [key]: "lit" }
+        const had = key in o
+        delete literal[key]
+        return [o.id, had, (({ [key]: v }) => v)(o), literal, o[[1, 2]] === undefined]
+      `),
+    ).toEqual([2, true, 2, {}, true])
+    expect(
+      await value(`
+        const seen = []
+        const base = { x: 1 }
+        base[{ toString() { seen.push(1); return "" } }] ^= 0
+        base[{ toString() { seen.push(2); return "x" } }]++
+        return [seen, base[""], base.x]
+      `),
+    ).toEqual([[1, 2], 0, 2])
+  })
+
+  test("valueOf is the fallback, a symbol result stays a symbol, and conversion failures surface", async () => {
+    expect(
+      await value(`
+        const o = { 7: "seven" }
+        const sym = { toString() { return Symbol.iterator } }
+        o[sym] = 1
+        return [o[{ valueOf() { return 7 }, toString: undefined }], typeof o[Symbol.iterator], Object.keys(o)]
+      `),
+    ).toEqual(["seven", "number", ["7"]])
+    expect((await error(`({})[{ toString() { throw new RangeError("bad key") } }]`)).message).toContain("bad key")
+    expect((await error(`({})[{ toString() { return {} }, valueOf() { return {} } }]`)).message).toContain(
+      "Cannot convert object to primitive value",
+    )
+    expect((await error(`const key = { toString() { return "a" } }; key in 5`)).message).toContain(
+      "requires a data object on the right-hand side",
+    )
+  })
+
+  test("a nullish base throws before the key converts, as ToObject precedes ToPropertyKey", async () => {
+    const failure = await error(`const base = null; base[{ toString() { throw new RangeError("key evaluated") } }]`)
+    expect(failure.message).toContain("Cannot read properties of null")
+  })
+
+  test("opaque values keep their built-in key form and a tool reference toString is never called", async () => {
+    expect(
+      await value(`
+        const o = { "[object Function]": 1, "[object Promise]": 2 }
+        return [o[() => 1], o[Promise.resolve("k")]]
+      `),
+    ).toEqual([1, 2])
+    expect((await error(`({})[{ toString: tools.nowhere }] = 1`)).message).toContain(
+      "Cannot convert object to primitive value",
+    )
+  })
+})
+
+describe("String and Number method arguments convert through ToPrimitive", () => {
+  test("string positions use the string hint and numeric positions the number hint", async () => {
+    expect(
+      await value(`
+        const s = { toString() { return "b" } }
+        const n = { valueOf() { return 1 } }
+        return [
+          "abc".indexOf(s), "abc".lastIndexOf(s), "abc".includes(s), "abc".startsWith(s, n), "abc".endsWith(s, 2),
+          "abc".charAt(n), "abc".at({ valueOf() { return -1 } }), "abc".slice(n), "abc".substring(n, 2),
+          "abc".charCodeAt(n), "a".padStart({ valueOf() { return 3 } }, s), "x".padEnd(3, s), "ab".repeat({ valueOf() { return 2 } }),
+          "a".concat(s, { valueOf() { return 1 }, toString() { return "T" } }), "b".localeCompare(s),
+          (1.005).toFixed({ valueOf() { return 2 } }), (255).toString({ valueOf() { return 16 } }),
+          (1234.5678).toPrecision({ valueOf() { return 6 } }), (12345).toExponential({ valueOf() { return 2 } }),
+        ]
+      `),
+    ).toEqual([
+      1,
+      1,
+      true,
+      true,
+      true,
+      "b",
+      "c",
+      "bc",
+      "b",
+      98,
+      "bba",
+      "xbb",
+      "abab",
+      "abT",
+      0,
+      "1.00",
+      "ff",
+      "1234.57",
+      "1.23e+4",
+    ])
+  })
+
+  test("split, replace, match, and search convert a plain pattern but keep a RegExp as is", async () => {
+    expect(
+      await value(`
+        const s = { toString() { return "b" } }
+        return [
+          "abc".split(s), "abc".split(/b/, { valueOf() { return 1 } }), "abc".split(undefined, { valueOf() { return undefined } }),
+          "abc".replace(s, "X"), "abc".replace(/b/, { toString() { return "R" } }), "abc".replaceAll(s, s),
+          "abc".replace(s, (m) => m.toUpperCase()), "abc".match(s)[0], "abcb".matchAll(s).length, "abc".search(s),
+        ]
+      `),
+    ).toEqual([["a", "c"], ["a"], [], "aXc", "aRc", "abc", "aBc", "b", 2, 1])
+    expect((await error(`"abc".includes(/b/)`)).message).toContain("cannot take a regular expression")
+  })
+
+  test("the receiver converts first, then each consumed argument, in spec order; extra arguments are untouched", async () => {
+    expect(
+      await value(`
+        const log = []
+        const observer = (name, string, number) => ({
+          toString() { log.push("toString:" + name); return string },
+          valueOf() { log.push("valueOf:" + name); return number },
+        })
+        const padded = String.prototype.padStart.call(observer("receiver", {}, "abc"), observer("maxLength", 11, {}), observer("fillString", {}, "def"))
+        const extra = "abc".indexOf("b", 1, { valueOf() { throw new Error("extra argument converted") } })
+        return [padded, log, extra, String.prototype.trim.call({ toString() { return " abc " } })]
+      `),
+    ).toEqual([
+      "defdefdeabc",
+      [
+        "toString:receiver",
+        "valueOf:receiver",
+        "valueOf:maxLength",
+        "toString:maxLength",
+        "toString:fillString",
+        "valueOf:fillString",
+      ],
+      1,
+      "abc",
+    ])
+  })
+
+  test("conversion failures surface and opaque arguments still reject", async () => {
+    expect((await error(`"abc".indexOf({ toString() { throw new RangeError("intostr") } })`)).message).toContain(
+      "intostr",
+    )
+    expect((await error(`(1).toString({ valueOf() { throw new SyntaxError("poison") } })`)).message).toContain("poison")
+    expect((await error(`(1).toFixed({ toString() { return {} }, valueOf() { return {} } })`)).message).toContain(
+      "Cannot convert object to primitive value",
+    )
+    expect((await error(`"abc".indexOf(tools.nowhere)`)).message).toContain("expects argument 1 to be a data value")
+    expect((await error(`"abc".indexOf(Promise.resolve("b"))`)).message).toContain(
+      "expects argument 1 to be a data value",
+    )
+  })
+})
+
+describe("WeakMap and WeakSet", () => {
+  test("hold program objects by identity and answer like JS for non-object keys", async () => {
+    expect(
+      await value(`
+        const k = {}
+        const f = () => 1
+        const wm = new WeakMap([[k, 1]])
+        const ws = new WeakSet([k])
+        return [
+          wm.set(f, "fn") === wm, wm.get(k), wm.get(f), wm.has({}), wm.get(1), wm.has(1), wm.delete("s"),
+          wm.getOrInsert(k, 9), wm.getOrInsertComputed({}, (key) => typeof key),
+          ws.add(f) === ws, ws.has(k), ws.has(f), ws.has(1), ws.delete(k), ws.has(k),
+          String(wm), wm.size, "clear" in wm, Symbol.iterator in ws, JSON.stringify(wm),
+        ]
+      `),
+    ).toEqual([
+      true,
+      1,
+      "fn",
+      false,
+      null,
+      false,
+      false,
+      1,
+      "object",
+      true,
+      true,
+      true,
+      false,
+      true,
+      false,
+      "[object WeakMap]",
+      null,
+      false,
+      false,
+      "{}",
+    ])
+  })
+
+  test("reject primitive keys, plain calls, bad receivers, and cloning", async () => {
+    expect((await error(`new WeakMap().set(1, 1)`)).message).toContain("Invalid value used as weak map key")
+    expect((await error(`new WeakSet([1])`)).message).toContain("Invalid value used in weak set")
+    expect((await error(`WeakMap()`)).message).toContain("new")
+    expect((await error(`WeakMap.prototype.get.call(new Map(), {})`)).message).toContain("incompatible receiver")
+    expect((await error(`structuredClone(new WeakSet())`)).message).toContain("DataCloneError")
+  })
+})
+
+describe("small language leftovers", () => {
+  test("for...in walks the prototype chain and skips keys deleted before their turn", async () => {
+    expect(
+      await value(`
+        const o = Object.create({ a: 1, shadowed: 1 })
+        o.b = 2
+        o.shadowed = 3
+        const keys = []
+        for (const k in o) keys.push(k)
+        const live = { a: 1, b: 2, c: 3 }
+        const seen = []
+        for (const k in live) { seen.push(k); delete live.b; live.z = 1 }
+        const none = []
+        for (const k in []) none.push(k)
+        for (const k in new TypeError("x")) none.push(k)
+        return [keys, seen, none]
+      `),
+    ).toEqual([["b", "shadowed", "a"], ["a", "c"], []])
+  })
+
+  test("tagged template objects are frozen", async () => {
+    expect(
+      await value(`
+        const tag = (s) => s
+        const f = () => tag\`a\${1}b\`
+        return [f() === f(), Object.isFrozen(f()), Object.isFrozen(f().raw)]
+      `),
+    ).toEqual([true, true, true])
+    expect((await error("const tag = (s) => s; tag`a`[0] = 'x'")).message).toContain("read only")
+  })
+
+  test("Array.prototype.toString delegates to join", async () => {
+    expect(
+      await value(`
+        const a = [1, 2]
+        a.join = () => "j"
+        const b = [1]
+        b.join = 5
+        return [a + "", String(a), \`\${a}\`, b.toString(), Array.prototype.toString.call([3, [4]])]
+      `),
+    ).toEqual(["j", "j", "j", "[object Array]", "3,4"])
+  })
+
+  test("Error.prototype.toString converts object name and message", async () => {
+    expect(
+      await value(`
+        const e = new Error("m")
+        e.message = { toString() { return "obj" } }
+        e.name = { valueOf() { return "N" }, toString() { return "T" } }
+        return [String(e), Error.prototype.toString.call({ name: "", message: "m" }), Error.prototype.toString.call({})]
+      `),
+    ).toEqual(["T: obj", "m", "Error"])
+    expect(
+      (await error(`const e = new Error(); e.message = { toString() { throw new RangeError("r") } }; String(e)`))
+        .message,
+    ).toContain("r")
+  })
+
+  test("generator functions inherit from GeneratorFunction.prototype", async () => {
+    expect(
+      await value(`
+        function* g() {}
+        async function* ag() {}
+        const GFP = Object.getPrototypeOf(g)
+        g.prototype = null
+        return [
+          typeof GFP, GFP === Function.prototype, Object.getPrototypeOf(GFP) === Function.prototype,
+          GFP.prototype.constructor === GFP, Object.getPrototypeOf(ag) === GFP, typeof g.bind,
+          Object.getPrototypeOf(g()) === GFP.prototype,
+        ]
+      `),
+    ).toEqual(["object", false, true, true, false, "function", true])
+    expect((await error(`function* g() {} Object.getPrototypeOf(g)()`)).message).toContain("not a function")
+  })
+})
@@ -12,7 +12,8 @@ Without them the runner registers no tests, so CI is unaffected. Licensed under

 ## Layout

- `manifest.json` — the pinned upstream revision, which upstream directories are copied, and what is left out.
+- `manifest.json` — the pinned upstream revision, which upstream directories are copied (every `built-ins` and
+  `language` directory, about 14,900 files after filtering), and what is left out.
 - `built-ins/`, `language/` — the copied files, mirroring upstream `test/`; gitignored.
 - `skipped.txt` — vendored files that fail on a known interpreter gap, one `path  # reason` per line. They are
  skipped, and each gap is listed as unchecked in `interpreter-support.md`.
@@ -26,7 +27,8 @@ Without them the runner registers no tests, so CI is unaffected. Licensed under
 manifest marks unsupported, or when its code matches one of the manifest's `boundaries` patterns. The sync checks the
 checkout is at the pinned revision, so every machine runs the same files. Boundaries are
 intentional limits of the interpreter, not compatibility work: classes, prototype objects, property descriptors,
-accessors, boxed primitives, sloppy mode, `eval`, `Symbol()`, and the `$262` host API. If one
+accessors, boxed primitives, typed arrays and buffers, `WeakRef` and `FinalizationRegistry`, `Reflect` and `Proxy`, sloppy mode, `eval`,
+`Symbol()`, and the `$262` host API. If one
 of those decisions changes, delete its entry and re-sync; the tests are upstream, not lost.

 ## Commands
@@ -1,33 +1,16 @@
 {
  "revision": "250f204f23a9249ff204be2baec29600faae7b75",
-  "directories": [
-    "built-ins/Array/prototype",
-    "built-ins/Function/prototype/apply",
-    "built-ins/Function/prototype/bind",
-    "built-ins/Function/prototype/call",
-    "built-ins/Iterator",
-    "built-ins/Object/freeze",
-    "built-ins/Object/getPrototypeOf",
-    "built-ins/Object/is",
-    "built-ins/Object/isExtensible",
-    "built-ins/Object/isFrozen",
-    "built-ins/Object/isSealed",
-    "built-ins/Object/preventExtensions",
-    "built-ins/String/raw",
-    "language/arguments-object",
-    "language/expressions/does-not-equals",
-    "language/expressions/equals",
-    "language/expressions/tagged-template",
-    "language/expressions/this",
-    "language/statements"
-  ],
+  "directories": ["built-ins", "language"],
  "harness": ["assert.js", "sta.js", "compareArray.js", "doneprintHandle.js"],
  "flags": ["module", "raw", "noStrict"],
  "boundaries": {
    "class": "\\bclass\\s*[A-Za-z_${]",
    "accessor properties": "\\b(get|set)\\s+[\\w$\\[][^\\n(]*\\(",
    "property descriptors": "Object\\.(defineProperty|defineProperties|getOwnPropertyDescriptors?|getOwnPropertyNames|setPrototypeOf)\\b",
-    "boxed primitives": "\\bnew\\s+(String|Number|Boolean)\\s*\\(",
+    "boxed primitives": "\\b(new\\s+(String|Number|Boolean)\\b|Object\\s*\\(\\s*(true|false|-?\\d|['\"]))",
+    "typed arrays and buffers": "\\b(ArrayBuffer|SharedArrayBuffer|DataView|Int8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|Uint32Array|Float16Array|Float32Array|Float64Array|BigInt64Array|BigUint64Array)\\b",
+    "weak collections": "\\b(WeakRef|FinalizationRegistry)\\b",
+    "Reflect and Proxy": "\\b(Reflect|Proxy)\\b",
    "sloppy mode": "\\bwith\\s*\\(",
    "eval": "\\b(eval|Function)\\b",
    "new.target": "\\bnew\\.target\\b",
@@ -91,8 +74,6 @@
    "Uint16Array",
    "Uint32Array",
    "uint8array-base64",
-    "WeakMap",
-    "WeakSet",
    "WeakRef",
    "FinalizationRegistry",
    "Intl-enumeration",
@@ -354,3 +354,30 @@ describe("tools.search alias", () => {
    expect(await value(runtime, `return await tools.search({})`)).toBe("custom")
  })
 })
+
+describe("tool references under ==", () => {
+  test("compare by identity against data objects without converting them", async () => {
+    const runtime = CodeMode.make({ tools: { probe: echo("Probe", "ok") } })
+    expect(
+      await value(
+        runtime,
+        `let calls = 0
+         const o = { valueOf() { calls++; return 1 } }
+         return [o == tools.probe, tools == { a: 1 }, tools.probe == null, calls]`,
+      ),
+    ).toEqual([false, false, false, 0])
+  })
+})
+
+describe("tool reference identity", () => {
+  test("repeated member reads yield the same reference", async () => {
+    const runtime = CodeMode.make({ tools: { probe: echo("Probe", "ok"), "ns.inner": echo("Inner", "in") } })
+    expect(
+      await value(
+        runtime,
+        `return [tools.probe === tools.probe, tools.ns.inner === tools.ns.inner, tools.ns === tools.ns, tools["probe"] === tools.probe,
+                 tools.probe === tools.ns.inner, new Set([tools.probe, tools.probe]).size, await tools.ns.inner({})]`,
+      ),
+    ).toEqual([true, true, true, true, false, 1, "in"])
+  })
+})
@@ -13,6 +13,7 @@ import { Provider } from "../../provider.js"
 import { WebSearch } from "../../websearch.js"
 import { ConfigPolicy } from "@opencode/schema/config/policy"
 import { ConfigProvider } from "@opencode/schema/config/provider"
+import { Mcp } from "@opencode/schema/mcp"
 import { Money } from "@opencode/schema/money"

 const defaultServer = "https://opencode.ai/console"
@@ -23,6 +24,15 @@ const RemoteResponse = Schema.Struct({
  websearch: Schema.Struct({
    providerID: WebSearch.ID,
  }).pipe(Schema.optional),
+  // MCP servers by name, in the same shape as a remote server in local config. Only remote servers are
+  // accepted so the Console can never make the client run a command. `auth: "console"` asks the client
+  // to attach its own Console credential to that server's requests.
+  mcp: Schema.Struct({
+    servers: Schema.Record(
+      Schema.String,
+      Schema.Struct({ ...Mcp.RemoteConfig.fields, auth: Schema.Literal("console").pipe(Schema.optional) }),
+    ),
+  }).pipe(Schema.optional),
  // Organization policy compiled for the authenticated caller; omitted when there is none.
  experimental: Schema.Struct({
    policies: Schema.Array(ConfigPolicy.Info).pipe(Schema.optional),
@@ -134,19 +144,25 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Manag
      config: typeof RemoteResponse.Type | undefined
      connection: ActiveConnection
      organization: string | undefined
-    } = { config: undefined, connection: undefined, organization: undefined }
+      // Console MCP servers carry the credential in their headers, so a rotated token changes the snapshot.
+      mcp:
+        | { servers: NonNullable<typeof RemoteResponse.Type.mcp>["servers"]; headers: Record<string, string> }
+        | undefined
+    } = { config: undefined, connection: undefined, organization: undefined, mcp: undefined }

    const load = Effect.fn("OpencodePlugin.load")(function* () {
      const connection = yield* ctx.integration.connection.active("opencode")
-      if (!connection) return { config: undefined, connection, organization: undefined }
+      if (!connection) return { config: undefined, connection, organization: undefined, mcp: undefined }
      return yield* ctx.integration.connection.resolve(connection).pipe(
        Effect.flatMap((credential) => {
-          if (!credential) return Effect.succeed({ config: undefined, connection, organization: undefined })
+          if (!credential)
+            return Effect.succeed({ config: undefined, connection, organization: undefined, mcp: undefined })
          return fetchConfig(http, credential).pipe(
            Effect.map((config) => ({
              config,
              connection,
              organization: typeof credential.metadata?.orgName === "string" ? credential.metadata.orgName : undefined,
+              mcp: config?.mcp && { servers: config.mcp.servers, headers: credentialHeaders(credential) },
            })),
          )
        }),
@@ -156,8 +172,8 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Manag
            // would lift organization policy while personal credentials keep working.
            Effect.as(
              IntegrationConnection.key(connection) === IntegrationConnection.key(snapshot.connection)
-                ? { config: snapshot.config, connection, organization: snapshot.organization }
-                : { config: undefined, connection, organization: undefined },
+                ? { config: snapshot.config, connection, organization: snapshot.organization, mcp: snapshot.mcp }
+                : { config: undefined, connection, organization: undefined, mcp: undefined },
            ),
          ),
        ),
@@ -337,10 +353,24 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Manag
      editor.default.set(descriptor.providerID)
    })

+    yield* ctx.mcp.transform((editor) => {
+      const mcp = snapshot.mcp
+      if (!mcp) return
+      for (const [name, server] of Object.entries(mcp.servers)) {
+        // A server the user configured under the same name wins.
+        if (editor.get(name)) continue
+        const { auth, ...config } = server
+        editor.set(name, auth === "console" ? { ...config, headers: { ...config.headers, ...mcp.headers } } : config)
+      }
+    })
+
    const apply = Effect.fn("OpencodePlugin.apply")(function* (next: typeof snapshot) {
      snapshot = next
      yield* publish(next)
-      yield* Effect.all([ctx.provider.reload(), ctx.websearch.reload()], { concurrency: 2, discard: true })
+      yield* Effect.all([ctx.provider.reload(), ctx.websearch.reload(), ctx.mcp.reload()], {
+        concurrency: 3,
+        discard: true,
+      })
    })
    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(apply)))
    yield* bus.subscribe(Credential.Event.Switched).pipe(
@@ -364,15 +394,11 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Manag
 })

 function fetchConfig(http: HttpClient.HttpClient, value: Credential.Value) {
-  const metadata = value.metadata
-  const orgID = typeof metadata?.orgID === "string" ? metadata.orgID : undefined
-  const token = value.type === "oauth" ? value.access : value.key
  return http
    .execute(
      HttpClientRequest.get(`${serverUrl(value)}/api/v2/config`).pipe(
        HttpClientRequest.acceptJson,
-        HttpClientRequest.bearerToken(token),
-        HttpClientRequest.setHeaders(orgID ? { "x-org-id": orgID } : {}),
+        HttpClientRequest.setHeaders(credentialHeaders(value)),
      ),
    )
    .pipe(
@@ -385,6 +411,14 @@ function fetchConfig(http: HttpClient.HttpClient, value: Credential.Value) {
    )
 }

+function credentialHeaders(value: Credential.Value): Record<string, string> {
+  const orgID = value.metadata?.orgID
+  return {
+    authorization: `Bearer ${value.type === "oauth" ? value.access : value.key}`,
+    ...(typeof orgID === "string" ? { "x-org-id": orgID } : {}),
+  }
+}
+
 function serverUrl(value: Credential.Value) {
  return typeof value.metadata?.server === "string" ? value.metadata.server : defaultServer
 }
@@ -37,8 +37,9 @@ import { toLLMMessages } from "./runner/to-llm-message.js"
 import type { AgentNotFoundError } from "./error.js"
 import type { Instructions } from "../instructions/index.js"

-const AUTO_THRESHOLD = 0.85
+const DEFAULT_BUFFER = 20_000
 const DEFAULT_KEEP_TOKENS = 15_000
+const OUTPUT_TOKEN_MAX = 32_000
 const TOOL_OUTPUT_MAX_CHARS = 2_000
 const IMAGE_TOKEN_ESTIMATE = 1_500
 const PDF_TOKEN_ESTIMATE = 2_000
@@ -88,7 +89,7 @@ const LEGACY_HEADING = "## Additional Context"

 export type Settings = {
  auto: boolean
-  buffer?: number
+  buffer: number
  tokens: number
 }

@@ -400,7 +401,7 @@ export const layer = Layer.effect(

    const state = State.create<Settings & { readonly native: NativeStrategy[] }, Editor>({
      name: "session-compaction",
-      initial: () => ({ auto: true, tokens: DEFAULT_KEEP_TOKENS, native: [] }),
+      initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS, native: [] }),
      editor: (editor) => ({
        configure: (settings) => {
          if (settings.auto !== undefined) editor.auto = settings.auto
@@ -753,9 +754,11 @@ export const layer = Layer.effect(
      const limit = input.resolved.limit
      const context = limit.context
      if (context <= 0) return false
-      const usable = Math.min(context, limit.input ?? context)
-      const promptCeiling =
-        config.buffer === undefined ? Math.floor(usable * AUTO_THRESHOLD) : usable - config.buffer
+      const output = Math.min(limit.output, OUTPUT_TOKEN_MAX)
+      const promptCeiling = Math.min(
+        limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer,
+        context - Math.max(output, config.buffer),
+      )
      return estimateTokens(input) >= promptCeiling
    }
    const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
@@ -54,7 +54,8 @@ const modelID = (model: Model.Info) => model.modelID ?? model.id

 function claudeInfo(model: Model.Info) {
  const id = modelID(model)
-  const familyFirst = /(?:claude-)?(opus|sonnet|haiku|fable|mythos)-(\d+)(?:[.-](\d+))?/i.exec(id)
+  // Versions are at most two digits so snapshot dates such as `-20260901` are not read as versions.
+  const familyFirst = /(?:claude-)?(opus|sonnet|haiku|fable|mythos)-(\d{1,2})(?:[.-](\d{1,2}))?(?!\d)/i.exec(id)
  const versionFirst = /claude-(\d+)(?:[.-](\d+))?-(opus|sonnet|haiku|fable|mythos)/i.exec(id)
  const family = (familyFirst?.[1] ?? versionFirst?.[3])?.toLowerCase()
  const major = Number(familyFirst?.[2] ?? versionFirst?.[1])
@@ -64,7 +65,12 @@ function claudeInfo(model: Model.Info) {
    major,
    minor,
    manual: (major === 3 && minor === 7) || (major === 4 && minor < 6),
-    always: family === "fable" || family === "mythos" || id.toLowerCase().includes("mythos-preview"),
+    // Opus 5.5 and later reject disabled thinking.
+    always:
+      family === "fable" ||
+      family === "mythos" ||
+      id.toLowerCase().includes("mythos-preview") ||
+      (family === "opus" && (major > 5 || (major === 5 && minor >= 5))),
  }
 }

@@ -390,6 +396,7 @@ const bedrockConverse: Protocol = (model, support) => {
        return fields({ reasoningConfig: { type: "enabled", maxReasoningEffort: effort } })
      })
    case "toggle":
+      if (claude && claudeInfo(model).always) return []
      return claude
        ? toggle(fields({ thinking: { type: "disabled" } }), fields({ thinking: ADAPTIVE_THINKING }))
        : toggle(fields({ reasoningConfig: { type: "disabled" } }), fields({ reasoningConfig: { type: "enabled" } }))
@@ -449,6 +456,7 @@ const bedrockAISDK: Protocol = (model, support) => {
          : { reasoningConfig: { type: "enabled", maxReasoningEffort: effort } },
      }))
    case "toggle":
+      if (claude && claudeInfo(model).always) return []
      return claude
        ? toggle(
            { settings: { additionalModelRequestFields: { thinking: { type: "disabled" } } } },
@@ -507,6 +515,7 @@ const sapAICore: Protocol = (model, support) => {
          sap({ additionalModelRequestFields: { thinking: { type: "disabled" } } }),
          sap({ additionalModelRequestFields: { thinking: { type: "enabled" } } }),
        )
+      if (id.includes("anthropic") && claudeInfo(model).always) return []
      if (id.includes("anthropic"))
        return toggle(
          sap({ additionalModelRequestFields: { thinking: { type: "disabled" } } }),
@@ -172,5 +172,5 @@ const input = (tokens: number) => {
    },
  }
 }
-const bufferedInput = input(82_000)
+const bufferedInput = input(85_000)
 const nearInput = input(95_000)
@@ -5,26 +5,26 @@ import { Mcp } from "@opencode/core/mcp/index"
 import { AbsolutePath } from "@opencode/core/schema"
 import { location } from "./location"

-export const emptyMcpLayer = Layer.succeed(
-  Mcp.Service,
-  Mcp.Service.of({
-    transform: () => Effect.die("unused mcp.transform"),
-    reload: () => Effect.die("unused mcp.reload"),
-    servers: () => Effect.succeed([]),
-    add: () => Effect.die("unused mcp.add"),
-    connect: () => Effect.die("unused mcp.connect"),
-    disconnect: () => Effect.die("unused mcp.disconnect"),
-    remove: () => Effect.die("unused mcp.remove"),
-    tools: () => Effect.succeed([]),
-    callTool: () => Effect.die("unused mcp.callTool"),
-    instructions: () => Effect.succeed([]),
-    prompts: () => Effect.succeed([]),
-    prompt: () => Effect.undefined,
-    resourceCatalog: () => Effect.succeed(Mcp.ResourceCatalog.make({ resources: [], templates: [] })),
-    resources: () => Effect.succeed(Mcp.ResourceCatalog.make({ resources: [], templates: [] })),
-    readResource: () => Effect.undefined,
-  }),
-)
+// Plugins may register MCP transforms at startup; with no servers there is nothing to rebuild.
+export const emptyMcp = Mcp.Service.of({
+  transform: () => Effect.succeed({ dispose: Effect.void }),
+  reload: () => Effect.void,
+  servers: () => Effect.succeed([]),
+  add: () => Effect.die("unused mcp.add"),
+  connect: () => Effect.die("unused mcp.connect"),
+  disconnect: () => Effect.die("unused mcp.disconnect"),
+  remove: () => Effect.die("unused mcp.remove"),
+  tools: () => Effect.succeed([]),
+  callTool: () => Effect.die("unused mcp.callTool"),
+  instructions: () => Effect.succeed([]),
+  prompts: () => Effect.succeed([]),
+  prompt: () => Effect.undefined,
+  resourceCatalog: () => Effect.succeed(Mcp.ResourceCatalog.make({ resources: [], templates: [] })),
+  resources: () => Effect.succeed(Mcp.ResourceCatalog.make({ resources: [], templates: [] })),
+  readResource: () => Effect.undefined,
+})
+
+export const emptyMcpLayer = Layer.succeed(Mcp.Service, emptyMcp)

 export const emptyConfigLayer = Config.testLayer()

@@ -12,6 +12,7 @@ import { ConfigPolicyPlugin } from "@opencode/core/config/plugin/policy"
 import { Credential } from "@opencode/core/credential"
 import { Integration } from "@opencode/core/integration"
 import { ManagedPolicy } from "@opencode/core/managed-policy"
+import { Mcp } from "@opencode/core/mcp/index"
 import { Model } from "@opencode/core/model"
 import { ModelResolver } from "@opencode/core/model-resolver"
 import { Plugin } from "@opencode/core/plugin"
@@ -20,6 +21,7 @@ import { OpencodePlugin } from "@opencode/core/plugin/provider/opencode"
 import { Provider } from "@opencode/core/provider"
 import { WebSearch } from "@opencode/core/websearch"
 import { withEnv } from "../fixture/env"
+import { emptyMcp } from "../fixture/mcp"
 import { drain } from "../lib/clock"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -642,6 +644,110 @@ describe("OpencodePlugin", () => {
    ),
  )

+  it.effect("registers the Console's MCP servers as sent, attaching the credential only where asked", () =>
+    Effect.acquireUseRelease(
+      Effect.sync(() => {
+        const state = { advertised: true }
+        const server = Bun.serve({
+          port: 0,
+          fetch: (request) =>
+            Response.json({
+              providers: {},
+              ...(state.advertised
+                ? {
+                    mcp: {
+                      servers: {
+                        opencode_console: {
+                          type: "remote",
+                          url: `${new URL(request.url).origin}/console/mcp`,
+                          headers: { "x-client": "opencode", authorization: "Bearer forged" },
+                          oauth: false,
+                          auth: "console",
+                        },
+                        opencode_console_oauth: {
+                          type: "remote",
+                          url: `${new URL(request.url).origin}/console/oauth/mcp`,
+                          oauth: { scope: "workspace" },
+                          timeout: { startup: 5000 },
+                        },
+                      },
+                    },
+                  }
+                : {}),
+            }),
+        })
+        return { server, state }
+      }),
+      ({ server, state }) =>
+        Effect.gen(function* () {
+          const credentials = yield* Credential.Service
+          const transforms: Array<(editor: Mcp.Editor) => void> = []
+          const reloads = { count: 0 }
+          const servers = () => {
+            const configured = new Map<string, unknown>()
+            transforms.forEach((transform) =>
+              transform({
+                list: () => [],
+                get: (name) => (configured.has(name) ? { type: "remote", url: "user" } : undefined),
+                set: (name, config) => configured.set(name, config),
+                update: () => {},
+                remove: (name) => configured.delete(name),
+              }),
+            )
+            return Object.fromEntries(configured)
+          }
+          yield* credentials.create({
+            integrationID: Integration.ID.make("opencode"),
+            value: Credential.Key.make({
+              type: "key",
+              key: "secret",
+              metadata: { server: server.url.origin, orgID: "org-a" },
+            }),
+          })
+          yield* addPlugin().pipe(
+            Effect.provideService(
+              Mcp.Service,
+              Mcp.Service.of({
+                ...emptyMcp,
+                transform: (transform) =>
+                  Effect.sync(() => {
+                    transforms.push(transform)
+                    return { dispose: Effect.void }
+                  }),
+                reload: () =>
+                  Effect.sync(() => {
+                    reloads.count++
+                  }),
+              }),
+            ),
+          )
+          yield* drain
+
+          expect(servers()).toEqual({
+            opencode_console: {
+              type: "remote",
+              url: `${server.url.origin}/console/mcp`,
+              headers: { "x-client": "opencode", authorization: "Bearer secret", "x-org-id": "org-a" },
+              oauth: false,
+            },
+            opencode_console_oauth: {
+              type: "remote",
+              url: `${server.url.origin}/console/oauth/mcp`,
+              oauth: { scope: "workspace" },
+              timeout: { startup: 5000 },
+            },
+          })
+
+          state.advertised = false
+          yield* TestClock.adjust("1 minute")
+          yield* drain
+          expect(servers()).toEqual({})
+          expect(reloads.count).toBe(1)
+        }),
+      ({ server }) => Effect.promise(() => server.stop(true)),
+    ),
+  )
+
  it.effect("enforces organization policy statements from the Console", () =>
    Effect.acquireUseRelease(
      Effect.sync(() =>
@@ -153,7 +153,7 @@ test("compaction prompts prohibit task execution", () => {
    expect(SessionCompaction.buildPrompt(update)).toContain("Do not continue the task or call tools")
 })

-it.effect("auto compaction uses 85% by default and a configured buffer instead", () =>
+it.effect("auto compaction estimates current content against the buffered prompt ceiling", () =>
  Effect.gen(function* () {
    const compaction = yield* SessionCompaction.Service
    const session = Session.Info.make({
@@ -205,27 +205,23 @@ it.effect("auto compaction uses 85% by default and a configured buffer instead",
    }

    const inputLimited = { context: 400_000, input: 272_000, output: 128_000 }
-    expect(compaction.required(input(231_199, inputLimited))).toBe(false)
-    expect(compaction.required(input(231_200, inputLimited))).toBe(true)
+    expect(compaction.required(input(251_999, inputLimited))).toBe(false)
+    expect(compaction.required(input(252_000, inputLimited))).toBe(true)
    const native = (tokens: number, limit: { context: number; input?: number; output: number } = inputLimited) => {
      const selected = input(tokens, limit)
      return { ...selected, resolved: { ...selected.resolved, compaction: { type: "native" as const } } }
    }
-    expect(compaction.required(native(231_199))).toBe(false)
-    expect(compaction.required(native(231_200))).toBe(true)
+    expect(compaction.required(native(251_999))).toBe(false)
+    expect(compaction.required(native(252_000))).toBe(true)
    expect(compaction.required(native(1_000_000, { context: 0, input: undefined, output: 0 }))).toBe(false)

    const contextLimited = { context: 100_000, output: 10_000 }
-    expect(compaction.required(input(84_999, contextLimited))).toBe(false)
-    expect(compaction.required(input(85_000, contextLimited))).toBe(true)
+    expect(compaction.required(input(79_999, contextLimited))).toBe(false)
+    expect(compaction.required(input(80_000, contextLimited))).toBe(true)

    const outputLimited = { context: 100_000, output: 30_000 }
-    expect(compaction.required(input(84_999, outputLimited))).toBe(false)
-    expect(compaction.required(input(85_000, outputLimited))).toBe(true)
-
-    const smallWindow = { context: 32_000, output: 32_000 }
-    expect(compaction.required(input(27_199, smallWindow))).toBe(false)
-    expect(compaction.required(input(27_200, smallWindow))).toBe(true)
+    expect(compaction.required(input(69_999, outputLimited))).toBe(false)
+    expect(compaction.required(input(70_000, outputLimited))).toBe(true)

    const assistant = input(79_000, contextLimited).messages[0]
    const tool = SessionMessage.AssistantTool.make({
@@ -237,9 +233,7 @@ it.effect("auto compaction uses 85% by default and a configured buffer instead",
    })
    const grown = { ...input(79_000, contextLimited), messages: [{ ...assistant, content: [tool] }] }
    expect(SessionCompaction.estimateTokens(grown)).toBe(80_000)
-    expect(compaction.required(grown)).toBe(false)
-    const near = input(84_000, contextLimited)
-    expect(compaction.required({ ...near, messages: [{ ...near.messages[0], content: [tool] }] })).toBe(true)
+    expect(compaction.required(grown)).toBe(true)

    const interrupted = { ...assistant, id: SessionMessage.ID.create(), tokens: undefined }
    expect(SessionCompaction.estimateTokens({ ...grown, messages: [...grown.messages, interrupted] })).toBe(80_001)
@@ -291,13 +285,6 @@ it.effect("auto compaction uses 85% by default and a configured buffer instead",
      time: { created: 0, completed: 0 },
    })
    expect(compaction.required({ ...grown, messages: [checkpoint] })).toBe(false)
-
-    yield* compaction.transform((editor) => editor.configure({ buffer: 10_000 }))
-    expect(compaction.required(input(89_999, contextLimited))).toBe(false)
-    expect(compaction.required(input(90_000, contextLimited))).toBe(true)
-    yield* compaction.transform((editor) => editor.configure({ buffer: 0 }))
-    expect(compaction.required(input(99_999, contextLimited))).toBe(false)
-    expect(compaction.required(input(100_000, contextLimited))).toBe(true)
  }),
 )

@@ -2883,7 +2883,7 @@ describe("SessionRunnerLLM", () => {
        agent.steps = 2
      }),
    )
-    yield* s.llm.push(TestLLM.textWithUsage("Earlier answer", "before-native", 36_000))
+    yield* s.llm.push(TestLLM.textWithUsage("Earlier answer", "before-native", 10_000))
    yield* s.runPrompt("First real request")
    const checkpoint = (encrypted: string) =>
      CompactionCheckpointResponse.make({
@@ -2903,7 +2903,7 @@ describe("SessionRunnerLLM", () => {
    const installed = (yield* s.messages).filter((message) => message.type === "compaction")
    expect(installed).toMatchObject([{ status: "completed", reason: "auto", providerContext: { version: 1 } }])
    // New input without a post-checkpoint usage anchor must not retrigger compaction.
-    yield* s.llm.push(TestLLM.textWithUsage("Measured", "measured", 36_000))
+    yield* s.llm.push(TestLLM.textWithUsage("Measured", "measured", 10_000))
    yield* s.runPrompt("Third real request")
    expect(s.requests).toHaveLength(5)
    yield* s.llm.push(checkpoint("second"), TestLLM.textWithUsage("Continued", "continued", 10_000))
@@ -2929,7 +2929,7 @@ describe("SessionRunnerLLM", () => {
    s.currentModel = LanguageModel.make({ id: "native", provider: "openai", route: OpenAIResponses.route })
    modelLimits.set("native", { context: 42_000, output: 32_000 })
    s.compaction = { type: "native" }
-    yield* s.llm.push(TestLLM.textWithUsage("Earlier answer", "before-native", 36_000))
+    yield* s.llm.push(TestLLM.textWithUsage("Earlier answer", "before-native", 10_000))
    yield* s.runPrompt("Original durable request")
    yield* s.llm.push(
      CompactionCheckpointResponse.make({
@@ -104,6 +104,30 @@ test("recognizes Claude version spellings and future models", () => {
  ])
 })

+test("keeps thinking on for Claude Opus 5.5 and later", () => {
+  const supports: Variant.Support[] = [{ type: "toggle" }, { type: "effort", values: ["low", "high"] }]
+  const adaptive = ["low", "high"].map((effort) => ({
+    id: effort,
+    settings: { effort, thinking: { type: "adaptive", display: "summarized" } },
+  }))
+  for (const input of [
+    model("@opencode/ai/providers/cloudflare-ai-gateway", "anthropic/claude-opus-5.5"),
+    model("@opencode/ai/providers/anthropic", "claude-opus-5-5"),
+    model("@opencode/ai/providers/anthropic", "claude-opus-6"),
+  ])
+    expect(resolve(input, supports)).toEqual(adaptive)
+
+  expect(
+    resolve(model("@opencode/ai/providers/amazon-bedrock", "us.anthropic.claude-opus-5-5-v1:0"), [{ type: "toggle" }]),
+  ).toEqual([])
+
+  for (const id of ["claude-opus-5", "claude-opus-5-20260901"])
+    expect(resolve(model("@opencode/ai/providers/anthropic", id), supports)).toEqual([
+      { id: "none", settings: { thinking: { type: "disabled" } } },
+      ...adaptive,
+    ])
+})
+
 test("spells Cloudflare AI Gateway variants for their upstream routes", () => {
  const pkg = "@opencode/ai/providers/cloudflare-ai-gateway"
  expect(resolve(model(pkg, "openai/gpt-5.4"), [{ type: "effort", values: ["low", "xhigh"] }])).toEqual([
@@ -361,6 +361,12 @@ export function createBrowserPage(
      visible = value
      updateVisibility()
    },
+    // Freezes the shown page so the renderer can paint it under DOM overlays while the view hides.
+    async capture() {
+      if (closed || !visible || !content) return
+      const image = await contents.capturePage()
+      return image.isEmpty() ? undefined : new Uint8Array(image.toJPEG(90))
+    },
    async execute(command: Browser.Command, signal: AbortSignal): Promise<Browser.Result> {
      await ready
      abortError(signal)
@@ -288,6 +288,9 @@ export function createBrowserPane(storage: StateStore) {
      page.layout(bounds, value.background, value.radius)
      page.setVisible(true)
    },
+    async capture(win: BrowserWindow, bindingID: string, tabID: Browser.TabID) {
+      return (await owned(win, bindingID).pages.get(tabID)?.capture()) ?? null
+    },
    async command(win: BrowserWindow, bindingID: string, command: BrowserPaneCommand) {
      const entry = owned(win, bindingID)
      await execute(entry, { action: command, files: [] }, new AbortController().signal)
@@ -6,7 +6,7 @@ import { IpcPortHandoff } from "../ipc-transport"
 import { Shutdown } from "../lifecycle/shutdown"
 import { isRendererUrl } from "../windows/scheme"
 import { DesktopStorage } from "../storage"
-import { sender } from "./context"
+import { sender, type RpcContext } from "./context"

 export const eventHandlers = EventRpcs.toLayer(
  Effect.gen(function* () {
@@ -25,21 +25,29 @@ export const eventHandlers = EventRpcs.toLayer(
    })
    const remove = yield* shutdown.add(stop)
    yield* Effect.addFinalizer(() => Effect.sync(remove).pipe(Effect.andThen(stop)))
+    const owner = async (context: RpcContext) => {
+      const contents = sender(handoff, context)
+      const win = BrowserWindow.fromWebContents(contents)
+      if (!win || win.isDestroyed() || win.webContents !== contents || !isRendererUrl(contents.getURL())) {
+        throw new Error("browser.pane.owner.invalid")
+      }
+      browser ??= load()
+      return { win, pane: await browser }
+    }
    return EventRpcs.of({
      DesktopEvents: (_request, context) => ipcEventStream(sender(handoff, context).id),
      BrowserPane: ({ request }, context) =>
        Effect.tryPromise(async () => {
-          const contents = sender(handoff, context)
-          const win = BrowserWindow.fromWebContents(contents)
-          if (!win || win.isDestroyed() || win.webContents !== contents || !isRendererUrl(contents.getURL())) {
-            throw new Error("browser.pane.owner.invalid")
-          }
-          browser ??= load()
-          const pane = await browser
-          if (request.type === "register") return pane.register(win, request.bindingID, request.target)
-          if (request.type === "layout") return pane.layout(win, request.bindingID, request.layout)
-          if (request.type === "command") return pane.command(win, request.bindingID, request.command)
-          return pane.close(win, request.bindingID)
+          const target = await owner(context)
+          if (request.type === "register") return target.pane.register(target.win, request.bindingID, request.target)
+          if (request.type === "layout") return target.pane.layout(target.win, request.bindingID, request.layout)
+          if (request.type === "command") return target.pane.command(target.win, request.bindingID, request.command)
+          return target.pane.close(target.win, request.bindingID)
+        }).pipe(Effect.orDie),
+      BrowserPaneCapture: (request, context) =>
+        Effect.tryPromise(async () => {
+          const target = await owner(context)
+          return target.pane.capture(target.win, request.bindingID, request.tabID)
        }).pipe(Effect.orDie),
    })
  }),
@@ -4,6 +4,7 @@ import type { DesktopNativeBundle } from "@opencode/app/i18n/desktop-native"
 import type { UpdaterState } from "@opencode/app/updater"
 import type { WslServersPlatform } from "@opencode/app/wsl/types"
 import type { SshPlatform } from "@opencode/app/ssh"
+import type { Browser } from "@opencode/plugin-browser/rpc"
 import type { BrowserPaneRequest } from "../shared/ipc-rpc/browser"
 import type { WindowBootstrap } from "../shared/window-bootstrap"
 import type {
@@ -31,6 +32,7 @@ export type ElectronAPI = {
  browserPane: {
    request(request: BrowserPaneRequest): Promise<void>
    send(request: BrowserPaneRequest): void
+    capture(bindingID: string, tabID: Browser.TabID): Promise<ArrayBuffer | null>
    onEvent(callback: (value: { readonly bindingID: string; readonly event: BrowserPaneEvent }) => void): () => void
  }
  wslServers: WslServersAPI
@@ -50,6 +50,8 @@ export const api: ElectronAPI = {
  browserPane: {
    request: (request) => invoke("BrowserPane", { request }),
    send: (request) => send("BrowserPane", { request }),
+    capture: (bindingID, tabID) =>
+      invoke("BrowserPaneCapture", { bindingID, tabID }).then((data) => (data ? toArrayBuffer(data) : null)),
    onEvent: (callback) => listen("BrowserPaneEvent", (value) => callback(value)),
  },
  wslServers: {
@@ -46,6 +46,10 @@ export function createDesktopPlatform(
                .catch(() => undefined)
          },
          command: (command) => ready.then(() => api.browserPane.request({ type: "command", bindingID, command })),
+          capture: (tabID) =>
+            ready
+              .then(() => api.browserPane.capture(bindingID, tabID))
+              .then((data) => data && new Blob([data], { type: "image/jpeg" })),
          close() {
            if (closed) return
            closed = true
@@ -1,6 +1,7 @@
 import { Browser } from "@opencode/plugin-browser/rpc"
 import { Schema } from "effect"
 import { Rpc } from "effect/unstable/rpc"
+import { Transferable } from "effect/unstable/workers"

 const text = (maximum: number) => Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(maximum))
 const bindingID = text(128)
@@ -42,3 +43,7 @@ export const BrowserPaneEventSchema = Schema.Union([
  }),
 ])
 export const BrowserPaneRpc = Rpc.make("BrowserPane", { payload: { request: BrowserPaneRequestSchema } })
+export const BrowserPaneCaptureRpc = Rpc.make("BrowserPaneCapture", {
+  payload: { bindingID, tabID: Browser.TabID },
+  success: Schema.NullOr(Transferable.Uint8Array),
+})
@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { Rpc, RpcGroup } from "effect/unstable/rpc"
-import { BrowserPaneEventSchema, BrowserPaneRpc } from "./browser"
+import { BrowserPaneCaptureRpc, BrowserPaneEventSchema, BrowserPaneRpc } from "./browser"
 import { UpdaterStateSchema } from "./updater"
 import { WslServersEventSchema } from "./wsl"
 import { SshState } from "@opencode/app/ssh"
@@ -63,4 +63,4 @@ export const DesktopEvent = Schema.Union([
 export type DesktopEvent = Schema.Schema.Type<typeof DesktopEvent>

 export const DesktopEvents = Rpc.make("DesktopEvents", { success: DesktopEvent, stream: true })
-export const EventRpcs = RpcGroup.make(DesktopEvents, BrowserPaneRpc)
+export const EventRpcs = RpcGroup.make(DesktopEvents, BrowserPaneRpc, BrowserPaneCaptureRpc)
@@ -71,6 +71,10 @@ async function main() {
            void ready.then(() => pane.layout(win, bindingID, layout))
          },
          command: (command) => ready.then(() => pane.command(win, bindingID, command)),
+          capture: (tabID) =>
+            ready
+              .then(() => pane.capture(win, bindingID, tabID))
+              .then((data) => data && new Blob([data], { type: "image/jpeg" })),
          close: () => {
            listeners.delete(bindingID)
            void ready.then(() => pane.close(win, bindingID)).catch(() => {})
@@ -333,6 +333,11 @@ async function main() {
    await call("tabs.focus", { tabID: second.id })
    pane.layout(win, "suite", { tabID: second.id, visible: true, bounds: { x: 0, y: 0, width: 1000, height: 700 } })
    const snap = await call("snapshot", { tabID, boxes: true })
+    const still = await until(() => pane.capture(win, "suite", second.id))
+    assert(still)
+    assert.deepEqual(Array.from(still.subarray(0, 2)), [0xff, 0xd8], "The shown page captures as a JPEG still")
+    assert.equal(await pane.capture(win, "suite", tabID), null, "A hidden page has no still to show")
+    console.log("PASS browser pane still capture")
    const ref = (text: string) => {
      const match = snap.content
        .split("\n")
@@ -39,8 +39,8 @@
  },
  "peerDependencies": {
    "@opencode/theme": "workspace:*",
-    "@opentui/core": ">=0.5.10",
-    "@opentui/solid": ">=0.5.10",
+    "@opentui/core": ">=0.5.12",
+    "@opentui/solid": ">=0.5.12",
    "solid-js": ">=1.9.0"
  },
  "peerDependenciesMeta": {
@@ -1,31 +1,61 @@
 /** @jsxImportSource @opentui/solid */
-import { DiffRenderable, LineNumberRenderable, type ColorInput } from "@opentui/core"
+import {
+  BoxRenderable,
+  CodeRenderable,
+  DiffRenderable,
+  getTreeSitterClient,
+  LineNumberRenderable,
+  type ColorInput,
+  type OnHighlightCallback,
+  type Renderable,
+  type ScrollBoxRenderable,
+  type SimpleHighlight,
+} from "@opentui/core"
 import type { JSX } from "@opentui/solid"
-import { createMemo, For, Show, splitProps } from "solid-js"
-import { splitPatchHunks } from "../util/diff"
+import { useRenderer } from "@opentui/solid"
+import { batch, createMemo, createSignal, For, onCleanup, Show, splitProps } from "solid-js"
+import { splitAddedPatch, splitPatchHunks, type AddedPatchChunk } from "../util/diff"
 import { stringWidth } from "../util/string-width"

 export interface PatchDiffRef {
-  readonly hunks: () => readonly DiffRenderable[]
+  readonly hunks: () => readonly (DiffRenderable | BoxRenderable)[]
 }

+// Smaller patches render fine as a single DiffRenderable; only split files large enough to stall the TUI.
+const VIRTUAL_MIN_LINES = 3000
+const VIRTUAL_CHUNK_LINES = 128
+
 type Props = Omit<JSX.IntrinsicElements["diff"], "diff" | "lineNumberBg" | "ref"> & {
  diff: string
  hunkFg: ColorInput
  lineNumberBg: ColorInput
  ref?: (value: PatchDiffRef) => void
+  scroll?: () => ScrollBoxRenderable | undefined
 }

 export function PatchDiff(props: Props) {
-  const [local, diffProps] = splitProps(props, ["diff", "hunkFg", "lineNumberBg", "ref"])
+  const [local, diffProps] = splitProps(props, ["diff", "hunkFg", "lineNumberBg", "ref", "scroll"])
  const hunks = createMemo(() => splitPatchHunks(local.diff))
+  const chunks = createMemo(() => {
+    if (!local.scroll) return
+    const result = splitAddedPatch(local.diff, VIRTUAL_CHUNK_LINES)
+    return result && lineCount(result) > VIRTUAL_MIN_LINES ? result : undefined
+  })
+  // Virtual chunks mount independently, so size the gutter for the whole file rather than the mounted chunks.
+  const minDigits = createMemo(() => {
+    const items = chunks()
+    return items ? String(lineCount(items)).length : 0
+  })
  const nodes = new Map<number, DiffRenderable>()
+  let virtualRoot: BoxRenderable | undefined
  local.ref?.({
-    hunks: () =>
-      [...nodes.entries()]
+    hunks: () => {
+      if (chunks()) return virtualRoot && !virtualRoot.isDestroyed ? [virtualRoot] : []
+      return [...nodes.entries()]
        .sort(([left], [right]) => left - right)
        .map(([, node]) => node)
-        .filter((node) => !node.isDestroyed),
+        .filter((node) => !node.isDestroyed)
+    },
  })
  const syncGutters = (attempt = 0) => {
    requestAnimationFrame(() => {
@@ -44,10 +74,11 @@ export function PatchDiff(props: Props) {
      const maxAfter = Math.max(...after)
      if (!maxDigits && attempt < 2) return syncGutters(attempt + 1)
      if (!maxDigits) return
+      const width = Math.max(maxDigits, minDigits())
      sides.forEach((side) => {
        const index = sides.indexOf(side)
        const signs = new Map([...side.getLineSigns()].filter(([line]) => line >= 0))
-        signs.set(-1, { after: " ".repeat(maxAfter + maxDigits - digits[index]) })
+        signs.set(-1, { after: " ".repeat(maxAfter + width - digits[index]) })
        side.setLineNumbers(lineNumbers[index])
        side.setLineSigns(signs)
      })
@@ -55,29 +86,143 @@ export function PatchDiff(props: Props) {
  }
  const register = (index: number, node: DiffRenderable) => {
    nodes.set(index, node)
+    onCleanup(() => nodes.delete(index))
    syncGutters()
  }

  return (
-    <For each={hunks()}>
-      {(hunk, index) => (
-        <>
-          <Show when={index() > 0}>
-            <box width="100%" height={1} backgroundColor={local.lineNumberBg}>
-              <text fg={local.hunkFg} bg={local.lineNumberBg}>
-                {` ${hunk.header ?? ""}`}
-              </text>
-            </box>
-          </Show>
-          <diff
-            {...diffProps}
-            ref={(node: DiffRenderable) => register(index(), node)}
-            diff={hunk.patch}
-            minHeight={hunk.rows}
-            lineNumberBg={local.lineNumberBg}
-          />
-        </>
+    <Show
+      when={chunks()}
+      fallback={
+        <For each={hunks()}>
+          {(hunk, index) => (
+            <>
+              <Show when={index() > 0}>
+                <box width="100%" height={1} backgroundColor={local.lineNumberBg}>
+                  <text fg={local.hunkFg} bg={local.lineNumberBg}>
+                    {` ${hunk.header ?? ""}`}
+                  </text>
+                </box>
+              </Show>
+              <diff
+                {...diffProps}
+                ref={(node: DiffRenderable) => register(index(), node)}
+                diff={hunk.patch}
+                minHeight={hunk.rows}
+                lineNumberBg={local.lineNumberBg}
+              />
+            </>
+          )}
+        </For>
+      }
+    >
+      {(items) => (
+        <VirtualAddedPatch
+          chunks={items()}
+          scroll={local.scroll!}
+          diffProps={diffProps}
+          lineNumberBg={local.lineNumberBg}
+          register={register}
+          registerRoot={(root) => (virtualRoot = root)}
+        />
      )}
-    </For>
+    </Show>
  )
 }
+
+// Chunks render without wrapping so each one is exactly `rows` tall. Offscreen chunks become fixed-height
+// placeholders, and the chunks overlapping the viewport (plus one on each side) follow from the scroll offset.
+function VirtualAddedPatch(props: {
+  chunks: readonly AddedPatchChunk[]
+  scroll: () => ScrollBoxRenderable | undefined
+  diffProps: Omit<JSX.IntrinsicElements["diff"], "diff" | "lineNumberBg" | "ref">
+  lineNumberBg: ColorInput
+  register: (index: number, node: DiffRenderable) => void
+  registerRoot: (root: BoxRenderable) => void
+}) {
+  const renderer = useRenderer()
+  const [first, setFirst] = createSignal(0)
+  const [last, setLast] = createSignal(0)
+  // A chunk is not valid source on its own (a slice of a JSON object parses as an error), so highlight
+  // the whole file once and give each chunk its slice of the result.
+  const contents = createMemo(() => props.chunks.map((chunk) => chunk.lines.map((line) => line.slice(1)).join("\n")))
+  const offsets = createMemo(() =>
+    contents().map((_, index, all) => all.slice(0, index).reduce((sum, content) => sum + content.length + 1, 0)),
+  )
+  const fileHighlights = createMemo(() => {
+    const filetype = props.diffProps.filetype
+    if (!filetype) return
+    return (
+      getTreeSitterClient()
+        .highlightOnce(contents().join("\n"), filetype)
+        .then((result) => result.highlights)
+        // Rejects when the renderer tears down the client mid-parse; chunks then keep their own highlights.
+        .catch(() => undefined)
+    )
+  })
+  const chunkHighlights =
+    (index: number): OnHighlightCallback =>
+    async () => {
+      const all = await fileHighlights()
+      if (!all) return
+      const start = offsets()[index]
+      const end = start + contents()[index].length
+      return all.flatMap((highlight): SimpleHighlight[] =>
+        highlight[0] < end && highlight[1] > start
+          ? [[Math.max(highlight[0], start) - start, Math.min(highlight[1], end) - start, highlight[2], highlight[3]]]
+          : [],
+      )
+    }
+
+  return (
+    <box
+      width="100%"
+      ref={(root: BoxRenderable) => {
+        props.registerRoot(root)
+        root.onLifecyclePass = () => {
+          const scroll = props.scroll()
+          if (!scroll) return
+          // ScrollBox's scroll position is not a Solid signal; observe it during the render pass.
+          const top = scroll.scrollTop - (root.y - scroll.content.y)
+          batch(() => {
+            setFirst(Math.floor(top / VIRTUAL_CHUNK_LINES))
+            setLast(Math.floor((top + scroll.viewport.height) / VIRTUAL_CHUNK_LINES))
+          })
+        }
+        renderer.registerLifecyclePass(root)
+        onCleanup(() => renderer.unregisterLifecyclePass(root))
+      }}
+    >
+      <For each={props.chunks}>
+        {(chunk, index) => (
+          <Show when={index() >= first() - 1 && index() <= last() + 1} fallback={<box height={chunk.rows} />}>
+            <diff
+              {...props.diffProps}
+              ref={(node: DiffRenderable) => {
+                props.register(index(), node)
+                // DiffRenderable creates its CodeRenderable after ref runs; setting onHighlight re-highlights.
+                queueMicrotask(() => {
+                  const code = findCode(node)
+                  if (code) code.onHighlight = chunkHighlights(index())
+                })
+              }}
+              diff={chunk.patch}
+              wrapMode="none"
+              height={chunk.rows}
+              lineNumberBg={props.lineNumberBg}
+            />
+          </Show>
+        )}
+      </For>
+    </box>
+  )
+}
+
+function findCode(node: Renderable): CodeRenderable | undefined {
+  if (node instanceof CodeRenderable) return node
+  return node.getChildren().reduce<CodeRenderable | undefined>((found, child) => found ?? findCode(child), undefined)
+}
+
+function lineCount(chunks: readonly AddedPatchChunk[]) {
+  return chunks.reduce((count, chunk) => count + chunk.rows, 0)
+}
@@ -90,6 +90,8 @@ export type PromptProps = {
 export type PromptRef = {
  focused: boolean
  current: PromptInfo
+  mode: "normal" | "shell"
+  setMode(mode: "normal" | "shell"): void
  set(prompt: PromptInfo): void
  reset(): void
  blur(): void
@@ -672,6 +674,9 @@ export function Prompt(props: PromptProps) {
    get current() {
      return store.prompt
    },
+    get mode() {
+      return store.mode
+    },
    focus() {
      if (disabled()) return
      input.focus()
@@ -679,6 +684,9 @@ export function Prompt(props: PromptProps) {
    blur() {
      input.blur()
    },
+    setMode(mode) {
+      setStore("mode", mode)
+    },
    set(prompt) {
      input.setText(prompt.text)
      setStore("prompt", prompt)
@@ -129,6 +129,7 @@ export const Definitions = {
  "session.aside": keybind("none", "Ask a side question"),
  "session.cd": keybind("none", "Change working directory"),
  "session.queued_prompts": keybind("<leader>q", "Manage queued prompts"),
+  "queued_prompt.undo": keybind("ctrl+u", "Undo queued prompt"),
  "queued_prompt.delete": keybind("ctrl+d", "Delete queued prompt"),
  "session.toggle.exploration_grouping": keybind("none", "Toggle related tool call grouping"),
  "session.verbosity.cycle": keybind("none", "Cycle transcript verbosity"),
@@ -44,7 +44,7 @@ function segment(value: string) {
  return value
 }

-function createStorage(root: string, channel: string) {
+export function createStorage(root: string, channel: string) {
  const entries = new Map<string, { readonly value: Entry<object>; readonly reload: () => void }>()
  const memories = new Map<string, MemoryEntry<object>>()
  const pending = new Set<Promise<void>>()
@@ -110,18 +110,32 @@ function createStorage(root: string, channel: string) {
    },
  }

-  let reload: ReturnType<typeof setTimeout> | undefined
-  const watcher = watch(directory, () => {
-    clearTimeout(reload)
-    // Atomic writes notify for the temporary file before its final rename, and some
-    // platforms coalesce the rename event. Reload after the event burst has settled.
-    reload = setTimeout(() => entries.forEach((entry) => entry.reload()), 50)
-  })
+  let reloadTimer: ReturnType<typeof setTimeout> | undefined
+  let watcher: ReturnType<typeof watch> | undefined
+  try {
+    watcher = watch(directory, () => {
+      clearTimeout(reloadTimer)
+      // Atomic writes notify for the temporary file before its final rename, and some
+      // platforms coalesce the rename event. Reload after the event burst has settled.
+      reloadTimer = setTimeout(() => entries.forEach((entry) => entry.reload()), 50)
+    })
+    watcher.on("error", (error) => {
+      clearTimeout(reloadTimer)
+      watcher?.close()
+      watcher = undefined
+      console.error("Storage directory watcher failed, live-reload disabled", { directory, error })
+    })
+  } catch (error) {
+    // fs.watch throws synchronously (e.g. ENOSPC when the inotify watch limit is
+    // exhausted). Losing cross-process live-reload is recoverable; crashing the
+    // whole TUI over it is not, so degrade instead of propagating.
+    console.error("Failed to watch storage directory, live-reload disabled", { directory, error })
+  }
  return {
    storage,
    close: () => {
-      clearTimeout(reload)
-      watcher.close()
+      clearTimeout(reloadTimer)
+      watcher?.close()
    },
  }
 }
@@ -1024,6 +1024,7 @@ export function DiffViewerContent(props: {
                                        onCleanup(() => patchDiffByFileIndex.delete(entry.fileIndex))
                                      }}
                                      diff={patch()}
+                                      scroll={() => scroll}
                                      hunkFg={theme.diff.text.hunkHeader}
                                      view={entry.file.status === "modified" ? view() : "unified"}
                                      filetype={filetype(entry.file.file)}
@@ -539,7 +539,6 @@ export function RunCommandMenuBody(props: {
      return
    }

-
    if (item.action === "subagent") {
      props.onSubagent()
      return
@@ -949,6 +948,7 @@ export function RunQueuedPromptSelectBody(props: {
  prompts: Accessor<FooterQueuedPrompt[]>
  onClose: () => void
  onSelect: (prompt: FooterQueuedPrompt) => void
+  onUndo: (prompt: FooterQueuedPrompt) => void
  onDelete: (prompt: FooterQueuedPrompt) => void
  onRows?: (rows: number) => void
  mono?: boolean
@@ -970,10 +970,21 @@ export function RunQueuedPromptSelectBody(props: {
    onRows: props.onRows,
  })
  const shortcuts = Keymap.useShortcuts()
+  const undoShortcut = () => monoShortcut(shortcuts.get("queued_prompt.undo") ?? "", props.mono ?? false)
  const deleteShortcut = () => monoShortcut(shortcuts.get("queued_prompt.delete") ?? "", props.mono ?? false)
  Keymap.createLayer(() => ({
    priority: 1,
    commands: [
+      {
+        id: "queued_prompt.undo",
+        title: "Undo",
+        group: "Prompt",
+        run() {
+          const item = controller.items()[controller.menu.selected()]
+          if (!item) return false
+          props.onUndo(item.prompt)
+        },
+      },
      {
        id: "queued_prompt.delete",
        title: "Delete pending prompt",
@@ -1001,6 +1012,7 @@ export function RunQueuedPromptSelectBody(props: {
      hint={[
        controller.items()[controller.menu.selected()]?.prompt.delivery === "steer" ? "enter queue" : "enter steer",
        deleteShortcut() ? `${deleteShortcut()} delete` : undefined,
+        undoShortcut() ? `${undoShortcut()} undo` : undefined,
      ]
        .filter(Boolean)
        .join(" · ")}
@@ -160,7 +160,8 @@ export type PromptState = {
  onPaste: (event: PasteEvent) => Promise<void>
  onContentChange: () => void
  onSizeChange: () => void
-  replacePrompt: (prompt: RunPrompt) => void
+  current: () => RunPrompt
+  replacePrompt: (prompt: RunPrompt, cursor?: number) => void
  bind: (area?: TextareaRenderable) => void
 }

@@ -1544,6 +1545,10 @@ export function createPromptState(input: PromptInput): PromptState {
      scheduleRows()
    },
    onSizeChange: scheduleRows,
+    current: () => {
+      syncDraft()
+      return promptCopy(draft)
+    },
    replacePrompt: restore,
    bind,
  }
@@ -27,6 +27,8 @@ import {
 import { FOOTER_MENU_ROWS, RunFooterMenu } from "./footer.menu"
 import { RunFooterSubagentBody } from "./footer.subagent"
 import { RunPromptBody, createPromptState } from "./footer.prompt"
+import { promptAppend } from "./prompt.shared"
+import { promptOffsetWidth } from "../prompt/display"
 import { RunPermissionBody } from "./footer.permission"
 import { RunFormBody } from "./footer.form"
 import { createFormBodyState, type FormBodyState } from "./form.shared"
@@ -320,7 +322,7 @@ export function RunFooterView(props: RunFooterViewProps) {
  }

  const runQueuedAction = createSingleFlight<string>()
-  const queuedPromptAction = async (action: QueuedPromptAction, inboxID: string) => {
+  const queuedPromptAction = async (action: QueuedPromptAction, inboxID: string, failureLabel?: string) => {
    const run = props.onQueuedPromptAction
    if (!run) return false
    const result = await runQueuedAction(inboxID, async () => {
@@ -329,7 +331,9 @@ export function RunFooterView(props: RunFooterViewProps) {
        (error) => error,
      )
      if (!error) return true
-      props.onStatus(`failed to ${action === "cancel" ? "delete" : action} pending prompt: ${errorMessage(error)}`)
+      props.onStatus(
+        `failed to ${failureLabel ?? (action === "cancel" ? "delete" : action)} pending prompt: ${errorMessage(error)}`,
+      )
      return false
    })
    return result ?? false
@@ -795,6 +799,17 @@ export function RunFooterView(props: RunFooterViewProps) {
                              )
                                closePanel()
                            }}
+                            onUndo={async (item) => {
+                              const current = composer.current()
+                              if (current.mode === "shell" && current.text) {
+                                props.onStatus("leave shell mode before undoing a queued prompt")
+                                return
+                              }
+                              if (!(await queuedPromptAction("cancel", item.messageID, "undo"))) return
+                              closePanel()
+                              const next = promptAppend(composer.current(), item.prompt)
+                              composer.replacePrompt(next, promptOffsetWidth(next.text))
+                            }}
                            onDelete={(item) => {
                              void queuedPromptAction("cancel", item.messageID)
                            }}
@@ -93,6 +93,11 @@ function monoCode(renderable: CodeRenderable): void {
  const onChunks = renderable.onChunks
  renderable.onChunks = async (chunks, context) => monoChunks((await onChunks?.(chunks, context)) ?? chunks)
  renderable.treeSitterClient = monoTreeSitter(renderable.treeSitterClient)
+  // Streaming markdown writes the preview buffer here, skipping the setters below.
+  const updateStreamingPreview = renderable.updateStreamingPreview.bind(renderable)
+  renderable.updateStreamingPreview = (content, initialStyledText) => {
+    updateStreamingPreview(content, monoStyledText(initialStyledText))
+  }

  const initialDescriptor = Object.getOwnPropertyDescriptor(CodeRenderable.prototype, "initialStyledText")
  const contentDescriptor = Object.getOwnPropertyDescriptor(CodeRenderable.prototype, "content")
@@ -8,6 +8,7 @@
 // the current draft is saved and history begins. Arrowing past the end
 // restores the draft.
 export { displayCharAt, displaySlice, mentionTriggerIndex, slashTriggerIndex } from "../prompt/display"
+import { promptOffsetWidth } from "../prompt/display"
 import { stringWidth } from "../util/string-width"
 import type { RunPrompt } from "./types"

@@ -35,6 +36,30 @@ export function promptCopy(prompt: RunPrompt): RunPrompt {
  }
 }

+// Part ranges are textarea offsets, so shift by display width rather than string length.
+export function promptAppend(prompt: RunPrompt, following: RunPrompt): RunPrompt {
+  const text = prompt.text ? `${prompt.text}\n\n` : ""
+  const offset = promptOffsetWidth(text)
+  const shift = <T extends { start: number; end: number }>(range: T) => ({
+    ...range,
+    start: range.start + offset,
+    end: range.end + offset,
+  })
+  const command = prompt.text ? prompt.command : following.command
+  return {
+    text: text + following.text,
+    parts: [
+      ...structuredClone(prompt.parts),
+      ...structuredClone(following.parts).map((part) => {
+        if (!part.source) return part
+        if (part.type === "file") return { ...part, source: { ...part.source, text: shift(part.source.text) } }
+        return { ...part, source: shift(part.source) }
+      }),
+    ],
+    ...(command ? { command } : {}),
+  }
+}
+
 export function promptSame(a: RunPrompt, b: RunPrompt): boolean {
  return (
    a.mode === b.mode &&
@@ -6,6 +6,7 @@ import type { Types } from "effect"
 import { createSimpleContext } from "../context/helper"
 import { useTuiPaths } from "../context/runtime"
 import { appendText, readText, writeText } from "../util/persistence"
+import { promptOffsetWidth } from "./display"

 export type PastedText = {
  text: string
@@ -28,6 +29,34 @@ export type PromptPartRef = {

 export const emptyPrompt = (): PromptInfo => ({ text: "", files: [], agents: [], skills: [], pasted: [] })

+// Part ranges are textarea offsets, so shift by display width rather than string length.
+export function appendPrompt(prompt: PromptInfo, following: PromptInfo): PromptInfo {
+  const text = prompt.text ? `${prompt.text}\n\n` : ""
+  const offset = promptOffsetWidth(text)
+  const shift = <T extends { start: number; end: number }>(range: T, by: number) => ({
+    ...range,
+    start: range.start + by,
+    end: range.end + by,
+  })
+  const mentions = <T extends { mention?: { start: number; end: number } }>(
+    items: T[] | undefined,
+    next: T[] | undefined,
+  ) => [
+    ...(items ?? []).map((item) => ({ ...item, mention: item.mention && shift(item.mention, 0) })),
+    ...(next ?? []).map((item) => ({ ...item, mention: item.mention && shift(item.mention, offset) })),
+  ]
+  return {
+    text: text + following.text,
+    files: mentions(prompt.files, following.files),
+    agents: mentions(prompt.agents, following.agents),
+    skills: mentions(prompt.skills, following.skills),
+    pasted: [
+      ...prompt.pasted.map((part) => ({ ...part, source: shift(part.source, 0) })),
+      ...following.pasted.map((part) => ({ ...part, source: shift(part.source, offset) })),
+    ],
+  }
+}
+
 export const MAX_HISTORY_ENTRIES = 50

 export function parsePromptHistory(text: string) {
@@ -70,6 +70,7 @@ import { useToast } from "../../ui/toast"
 import stripAnsi from "strip-ansi"
 import { usePromptRef } from "../../context/prompt"
 import { projectedPromptInput } from "../../prompt/codec"
+import { appendPrompt } from "../../prompt/history"
 import { deduplicateVisibleImages } from "../../prompt/attachment"
 import { useEpilogue } from "../../context/epilogue"
 import { normalizePath } from "../../util/path"
@@ -211,7 +212,9 @@ export function Session(props: {
  )
  const pendingDeliveries = createMemo(() => new Map(pendingUsers().map((item) => [item.id, item.delivery])))
  const queuedPrompts = createMemo(() =>
-    pendingUsers().flatMap((item) => (item.delivery === "queue" ? [{ id: item.id, text: item.payload.text }] : [])),
+    pendingUsers().flatMap((item) =>
+      item.delivery === "queue" ? [{ id: item.id, text: item.payload.text, payload: item.payload }] : [],
+    ),
  )
  const [composer, setComposer] = createStore({
    open: false,
@@ -608,7 +611,7 @@ export function Session(props: {
  const dialog = useDialog()
  const renderer = useRenderer()
  const runPendingAction = createSingleFlight<string>()
-  const mutatePending = async (action: PendingAction, inboxID: string) => {
+  const mutatePending = async (action: PendingAction, inboxID: string, failureLabel?: string) => {
    const result = await runPendingAction(inboxID, async () => {
      const request =
        action === "steer"
@@ -621,7 +624,7 @@ export function Session(props: {
        (error) => error,
      )
      if (!error) return true
-      const label = action === "cancel" ? "delete" : action
+      const label = failureLabel ?? (action === "cancel" ? "delete" : action)
      toast.show({ title: `Failed to ${label} pending prompt`, message: errorMessage(error), variant: "error" })
      return false
    })
@@ -652,6 +655,26 @@ export function Session(props: {
              })
            },
          },
+          {
+            command: "queued_prompt.undo",
+            title: "undo",
+            onTrigger: (option) => {
+              const target = prompt()
+              const queued = queuedPrompts().find((item) => item.id === option.value)
+              if (!target || !queued) return
+              if (target.mode === "shell" && target.current.text) {
+                toast.show({ message: "Leave shell mode before undoing a queued prompt", variant: "error" })
+                return
+              }
+              void mutatePending("cancel", queued.id, "undo").then((undone) => {
+                if (!undone) return
+                target.setMode("normal")
+                target.set(appendPrompt(target.current, { ...projectedPromptInput(queued.payload), pasted: [] }))
+                dialog.clear()
+                target.focus()
+              })
+            },
+          },
        ]}
        footerHints={[{ title: "steer", label: "enter" }]}
      />
@@ -4,6 +4,39 @@ export interface PatchHunk {
  readonly rows?: number
 }

+export interface AddedPatchChunk {
+  readonly patch: string
+  readonly lines: readonly string[]
+  readonly rows: number
+}
+
+/**
+ * Splits a new-file patch into chunks of `size` lines, each a valid patch with its own `@@ -0,0 +start,count @@`
+ * header. Returns undefined for anything else: patches with context or removed lines would need old and new line
+ * numbers recomputed at every cut, so they are not split.
+ */
+export function splitAddedPatch(patch: string, size: number): AddedPatchChunk[] | undefined {
+  const header = /^@@ -0,0 \+1,(\d+) @@[^\n]*\n/m.exec(patch)
+  if (!header) return
+  const count = Number(header[1])
+  const lines = patch
+    .slice(header.index + header[0].length)
+    .replace(/\n$/, "")
+    .split("\n")
+  const marker = lines.at(-1)?.startsWith("\\ No newline at end of file") ? lines.pop() : undefined
+  if (lines.length !== count || lines.some((line) => !line.startsWith("+"))) return
+  const prefix = patch.slice(0, header.index)
+  return Array.from({ length: Math.ceil(count / size) }, (_, index) => {
+    const start = index * size
+    const slice = lines.slice(start, start + size)
+    return {
+      patch: `${prefix}@@ -0,0 +${start + 1},${slice.length} @@\n${slice.join("\n")}${marker && start + size >= count ? `\n${marker}` : ""}`,
+      lines: slice,
+      rows: slice.length,
+    }
+  })
+}
+
 export function splitPatchHunks(patch: string): PatchHunk[] {
  const starts = [...patch.matchAll(/^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@.*$/gm)].map((match) => match.index)
  if (starts.length <= 1) return [{ patch }]
@@ -2058,6 +2058,197 @@ const manyDiffs = Array.from({ length: 40 }, (_, index) => ({
  file: `file${String(index).padStart(2, "0")}.txt`,
 }))

+test.each([80, 160])("virtualizes a large added file at %i columns without losing its end", async (width) => {
+  const lines = [
+    "+{",
+    ...Array.from(
+      { length: 7500 },
+      (_, index) =>
+        `+  "row-${String(index).padStart(4, "0")}": "${"value".repeat(index === 777 ? 2000 : index % 7 === 0 ? 24 : 1)}"${index === 7499 ? "" : ","}`,
+    ),
+    "+}",
+  ]
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "snapshot.json",
+        status: "added",
+        additions: lines.length,
+        deletions: 0,
+        patch: `diff --git a/snapshot.json b/snapshot.json\nnew file mode 100644\n--- /dev/null\n+++ b/snapshot.json\n@@ -0,0 +1,${lines.length} @@\n${lines.join("\n")}`,
+      },
+    ],
+    { width, height: 24 },
+  )
+  try {
+    expect(viewer.app.captureCharFrame()).toContain("row-0000")
+    expect(
+      findDiffs(viewer.app.renderer.root).reduce((total, node) => total + node.diff.split("\n").length, 0),
+    ).toBeLessThan(2000)
+    viewer.commands.get("diff.last")!.run()
+    await viewer.app.flush()
+    if (!viewer.app.captureCharFrame().includes("row-7499")) {
+      await viewer.app.waitForFrame((frame) => frame.includes("row-7499"))
+    }
+    expect(viewer.app.captureCharFrame()).toContain("row-7499")
+    expect(
+      findDiffs(viewer.app.renderer.root).reduce((total, node) => total + node.diff.split("\n").length, 0),
+    ).toBeLessThan(2000)
+    viewer.commands.get("diff.first")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("row-0000")
+    viewer.app.resize(width === 80 ? 160 : 80, 20)
+    await viewer.app.flush()
+    viewer.commands.get("diff.last")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("row-7499")
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+test("keeps the line-number gutter the same width across virtual chunks", async () => {
+  const additions = Array.from({ length: 10500 }, (_, index) => `+line-${String(index + 1).padStart(5, "0")}`)
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "wide.txt",
+        status: "added",
+        additions: additions.length,
+        deletions: 0,
+        patch: `--- /dev/null\n+++ b/wide.txt\n@@ -0,0 +1,${additions.length} @@\n${additions.join("\n")}`,
+      },
+    ],
+    { width: 120, height: 24 },
+  )
+  const column = (text: string) =>
+    viewer.app
+      .captureCharFrame()
+      .split("\n")
+      .find((line) => line.includes(text))
+      ?.indexOf(text)
+  try {
+    await viewer.app.flush()
+    const top = column("line-00001")
+    viewer.commands.get("diff.last")!.run()
+    await viewer.app.flush()
+    if (!viewer.app.captureCharFrame().includes("line-10500")) {
+      await viewer.app.waitForFrame((frame) => frame.includes("line-10500"))
+    }
+    expect(top).toBeDefined()
+    expect(column("line-10500")).toBe(top)
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+test("highlights virtual chunks with whole-file syntax context", async () => {
+  const additions = Array.from({ length: 3200 }, (_, index) => {
+    if (index === 370) return "+/*"
+    if (index === 399) return "+*/"
+    if (index > 370 && index < 399) return `+  comment ${index}`
+    return `+const value${index} = ${index}`
+  })
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "big.ts",
+        status: "added",
+        additions: additions.length,
+        deletions: 0,
+        patch: `--- /dev/null\n+++ b/big.ts\n@@ -0,0 +1,${additions.length} @@\n${additions.join("\n")}`,
+      },
+    ],
+    { width: 120, height: 40 },
+  )
+  const color = (text: string) =>
+    viewer.app
+      .captureSpans()
+      .lines.flatMap((line) => line.spans)
+      .find((span) => span.text.includes(text))?.fg
+  try {
+    findScrollBox(viewer.app.renderer.root)!.scrollTo(360)
+    await viewer.app.flush()
+    // The comment starts in the first chunk and ends in the second; wait until it is highlighted.
+    for (let attempt = 0; attempt < 100 && `${color("comment 375")}` === `${color("value365")}`; attempt++) {
+      await Bun.sleep(20)
+      await viewer.app.flush()
+    }
+    expect(`${color("comment 375")}`).not.toBe(`${color("value365")}`)
+    for (let attempt = 0; attempt < 100 && `${color("comment 390")}` !== `${color("comment 375")}`; attempt++) {
+      await Bun.sleep(20)
+      await viewer.app.flush()
+    }
+    expect(`${color("comment 390")}`).toBe(`${color("comment 375")}`)
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+test("does not virtualize added files at or below the size threshold", async () => {
+  const additions = Array.from({ length: 3000 }, (_, index) => `+small line ${index}`)
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "small.txt",
+        status: "added",
+        additions: additions.length,
+        deletions: 0,
+        patch: `--- /dev/null\n+++ b/small.txt\n@@ -0,0 +1,${additions.length} @@\n${additions.join("\n")}`,
+      },
+    ],
+    { width: 120, height: 24 },
+  )
+  try {
+    expect(findDiffs(viewer.app.renderer.root)).toHaveLength(1)
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
+test("file navigation and review still work after a virtualized patch", async () => {
+  const additions = Array.from({ length: 6600 }, (_, index) => `+added line ${index}`)
+  const viewer = await renderDiffViewer(
+    [
+      {
+        file: "a-large.txt",
+        status: "added",
+        additions: additions.length,
+        deletions: 0,
+        patch: `--- /dev/null\n+++ b/a-large.txt\n@@ -0,0 +1,${additions.length} @@\n${additions.join("\n")}`,
+      },
+      { ...hunkDiff[0], file: "b-small.txt" },
+    ],
+    { width: 160, height: 24 },
+  )
+  try {
+    const scroll = findScrollBox(viewer.app.renderer.root)!
+    scroll.scrollTo(2700)
+    await viewer.app.flush()
+    viewer.commands.get("diff.previous_hunk")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("added line 0")
+    viewer.commands.get("diff.next_hunk")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("b-small.txt")
+    viewer.commands.get("diff.next_file")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("b-small.txt")
+    expect(viewer.app.captureCharFrame()).toContain("const first")
+    viewer.commands.get("diff.previous_file")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("a-large.txt")
+    viewer.commands.get("diff.mark_reviewed")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).not.toContain("added line 0")
+    viewer.commands.get("diff.mark_reviewed")!.run()
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("added line 0")
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
 function findScrollBox(root: Renderable, patches = true): ScrollBoxRenderable | undefined {
  const node = root.findDescendantById(patches ? "diff-patches" : "diff-files")
  return node instanceof ScrollBoxRenderable ? node : undefined
@@ -0,0 +1,37 @@
+import { afterEach, expect, spyOn, test } from "bun:test"
+import * as fs from "fs"
+import { mkdtempSync, rmSync } from "fs"
+import { tmpdir } from "os"
+import path from "path"
+import { createStorage } from "../../src/context/storage"
+
+afterEach(() => {
+  spyOn(fs, "watch").mockRestore()
+})
+
+test("createStorage degrades gracefully when fs.watch throws (e.g. ENOSPC)", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "storage-test-"))
+  // fs.watch throws synchronously when inotify_add_watch fails (e.g. the watch
+  // limit is exhausted). Simulate that scoped to this test only.
+  spyOn(fs, "watch").mockImplementation(() => {
+    throw Object.assign(new Error("ENOSPC: no space left on device, watch '/some/dir'"), { code: "ENOSPC" })
+  })
+
+  try {
+    let result: ReturnType<typeof createStorage> | undefined
+    expect(() => {
+      result = createStorage(dir, "next")
+    }).not.toThrow()
+
+    // storage should still be usable even though the live-reload watcher failed to attach
+    const [store, update] = result!.storage.store("kv", { initial: { count: 0 } })
+    expect(store.count).toBe(0)
+    await update((draft) => {
+      draft.count = 1
+    })
+    expect(store.count).toBe(1)
+    expect(() => result!.close()).not.toThrow()
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
@@ -1,6 +1,13 @@
 /** @jsxImportSource @opentui/solid */
 import { expect, test } from "bun:test"
-import { BoxRenderable, ImageRenderable, RGBA, type CliRenderer, type RootRenderable } from "@opentui/core"
+import {
+  BoxRenderable,
+  ImageRenderable,
+  RGBA,
+  TextareaRenderable,
+  type CliRenderer,
+  type RootRenderable,
+} from "@opentui/core"
 import { createTestRenderer } from "@opentui/core/testing"
 import { testRender } from "@opentui/solid"
 import { createSignal } from "solid-js"
@@ -1268,7 +1275,7 @@ test.each(["queue", "steer"] as const)("direct footer toggles and deletes pendin
    expect(frame).toContain("Pending prompts")
    expect(frame).toContain("follow up")
    expect(frame).toContain(delivery === "queue" ? "queued" : "steering")
-    expect(frame).toContain(`enter ${delivery === "queue" ? "steer" : "queue"} · ctrl+d delete`)
+    expect(frame).toContain(`enter ${delivery === "queue" ? "steer" : "queue"} · ctrl+d delete · ctrl+u undo`)
    expect(frame).not.toContain("┌")
    expect(frame).not.toContain("┃")
    expectPaletteList(list, 0)
@@ -1294,6 +1301,129 @@ test.each(["queue", "steer"] as const)("direct footer toggles and deletes pendin
  }
 })

+test("undo appends a pending prompt to the draft", async () => {
+  const actions: string[] = []
+  const submitted: RunPrompt[] = []
+  const queued: FooterQueuedPrompt = {
+    messageID: "m-1",
+    prompt: {
+      messageID: "m-1",
+      text: "look at main.ts",
+      parts: [],
+    },
+    delivery: "queue",
+  }
+  const app = await renderFooter({
+    queuedPrompts: [queued],
+    onSubmit: (prompt) => {
+      submitted.push(prompt)
+      return true
+    },
+    onQueuedPromptAction: async (action, inboxID) => {
+      actions.push(`${action}:${inboxID}`)
+      app.setQueuedPrompts([])
+    },
+  })
+  try {
+    await app.renderOnce()
+    await app.mockInput.typeText("existing draft")
+    app.mockInput.pressKey("x", { ctrl: true })
+    app.mockInput.pressKey("q")
+    await app.renderOnce()
+    app.mockInput.pressKey("u", { ctrl: true })
+    await Bun.sleep(0)
+    await app.renderOnce()
+    expect(actions).toEqual(["cancel:m-1"])
+    expect(app.captureCharFrame()).toContain("existing draft")
+    expect(app.captureCharFrame()).toContain("look at main.ts")
+    expect(app.captureCharFrame()).not.toContain("Pending prompts")
+    await app.waitFor(() => app.renderer.currentFocusedEditor instanceof TextareaRenderable)
+    app.mockInput.pressEnter()
+    await Bun.sleep(0)
+    await app.renderOnce()
+    expect(submitted).toMatchObject([{ text: "existing draft\n\nlook at main.ts" }])
+    expect(submitted[0].messageID).toBeUndefined()
+  } finally {
+    app.cleanup()
+  }
+})
+
+test("undo leaves the queue and input alone when cancellation fails", async () => {
+  const statuses: string[] = []
+  const app = await renderFooter({
+    queuedPrompts: [{ messageID: "m-1", prompt: { text: "still queued", parts: [] }, delivery: "queue" }],
+    onStatus: (status) => statuses.push(status),
+    onQueuedPromptAction: async () => {
+      throw new Error("cancel failed")
+    },
+  })
+  try {
+    await app.renderOnce()
+    app.mockInput.pressKey("x", { ctrl: true })
+    app.mockInput.pressKey("q")
+    await app.renderOnce()
+    app.mockInput.pressKey("u", { ctrl: true })
+    await Bun.sleep(0)
+    await app.renderOnce()
+    expect(statuses.at(-1)).toContain("failed to undo pending prompt: cancel failed")
+    expect(app.captureCharFrame()).toContain("Pending prompts")
+    app.mockInput.pressKey("ESCAPE")
+    await app.renderOnce()
+    expect(app.captureCharFrame()).not.toContain("still queued")
+  } finally {
+    app.cleanup()
+  }
+})
+
+test("undo retains mentioned files when the prompt is sent again", async () => {
+  const submitted: RunPrompt[] = []
+  const app = await renderFooter({
+    queuedPrompts: [
+      {
+        messageID: "m-1",
+        delivery: "queue",
+        prompt: {
+          messageID: "m-1",
+          text: "inspect @src/main.ts please",
+          parts: [
+            {
+              type: "file",
+              url: "file:///src/main.ts",
+              filename: "main.ts",
+              source: { type: "file", path: "src/main.ts", text: { start: 8, end: 20, value: "@src/main.ts" } },
+            },
+          ],
+        },
+      },
+    ],
+    onQueuedPromptAction: async () => {
+      app.setQueuedPrompts([])
+    },
+    onSubmit: (prompt) => {
+      submitted.push(prompt)
+      return true
+    },
+  })
+  try {
+    await app.renderOnce()
+    app.mockInput.pressKey("x", { ctrl: true })
+    app.mockInput.pressKey("q")
+    await app.renderOnce()
+    app.mockInput.pressKey("u", { ctrl: true })
+    await Bun.sleep(0)
+    await app.renderOnce()
+    expect(app.captureCharFrame()).toContain("inspect @src/main.ts please")
+    app.mockInput.pressEnter()
+    await Bun.sleep(0)
+    expect(submitted).toMatchObject([
+      { text: "inspect @src/main.ts please", parts: [{ type: "file", url: "file:///src/main.ts" }] },
+    ])
+    expect(submitted[0].messageID).toBeUndefined()
+  } finally {
+    app.cleanup()
+  }
+})
+
 test("direct footer steers the oldest queued prompt from an empty composer", async () => {
  const steered: string[] = []
  const app = await renderFooter({
@@ -5,6 +5,7 @@ import {
  isExitCommand,
  isNewCommand,
  movePromptHistory,
+  promptAppend,
  pushPromptHistory,
 } from "../../src/mini/prompt.shared"
 import type { RunPrompt } from "../../src/mini/types"
@@ -106,3 +107,28 @@ describe("run prompt shared", () => {
    expect(isCompactCommand("/summarize")).toBe(false)
  })
 })
+
+describe("promptAppend", () => {
+  test("appends on a new line and shifts part ranges by display width", () => {
+    const output = promptAppend(
+      prompt("日本", [{ type: "agent", name: "plan", source: { start: 0, end: 4, value: "日本" } }]),
+      {
+        messageID: "m-1",
+        ...prompt("@a.ts /x", [
+          { type: "file", url: "file:///a.ts", source: { type: "file", text: { start: 0, end: 5, value: "@a.ts" } } },
+          { type: "skill", id: "x", source: { start: 6, end: 8, value: "/x" } },
+        ]),
+      },
+    )
+
+    expect(output).toEqual({
+      text: "日本\n\n@a.ts /x",
+      parts: [
+        { type: "agent", name: "plan", source: { start: 0, end: 4, value: "日本" } },
+        { type: "file", url: "file:///a.ts", source: { type: "file", text: { start: 6, end: 11, value: "@a.ts" } } },
+        { type: "skill", id: "x", source: { start: 12, end: 14, value: "/x" } },
+      ],
+    })
+    expect(promptAppend(prompt(""), prompt("next"))).toEqual(prompt("next"))
+  })
+})
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aiden Cline	beab7df087	fix(codemode): enumerate inherited keys in for...in, intern tool references, freeze template objects, and delegate Array and Error toString	2026-09-25 12:01:22 -05:00
Shoubhit Dash	14fc63ba9e	fix(core): keep thinking on for Claude Opus 5.5 variants (#51338 )	2026-09-25 18:32:41 +05:30
opencode-agent[bot]andnexxeln	c34ffa117e	fix(ai): preserve Gemini 3.8 TTS WAV output (#51300 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-25 18:11:36 +05:30
opencode-agent[bot]vimtor vimtor	beeb14e910	feat(prompt): undo queued prompts back into the input (#51124 ) Co-authored-by: vimtor <36263538+vimtor@users.noreply.github.com> Co-authored-by: vimtor <vn4varro@gmail.com>	2026-09-25 14:36:29 +02:00
opencode-agent[bot]	aae42e2e75	chore(core): refresh bundled models.dev snapshot	2026-09-25 12:21:04 +00:00
opencode-agent[bot]vimtor vimtor	cc9011c1ae	fix(tui): virtualize large added-file diffs (#51122 ) Co-authored-by: vimtor <36263538+vimtor@users.noreply.github.com> Co-authored-by: vimtor <vn4varro@gmail.com>	2026-09-25 13:51:00 +02:00
Victor Navarro	6cd938e1e9	feat(core): register Console-hosted MCP servers (#51325 )	2026-09-25 13:16:04 +02:00
Jack	7de6b3fc15	docs(console): document Qwen3.8 Max (#51320 )	2026-09-25 19:13:45 +08:00
opencode-agent[bot]	c1c9a13993	chore: update nix node_modules hashes	2026-09-25 08:37:39 +00:00
Simon Klee	917d904f18	tui: update OpenTUI v0.5.12 (#50567 )	2026-09-25 08:17:14 +00:00
opencode-agent[bot]andBrendonovich	ee5b67eb84	fix(app): unify session project icon resolution (#51288 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-25 07:47:12 +00:00
Aiden Cline	048a47e89e	docs: focus compaction page on user-facing behavior (#51270 )	2026-09-25 00:21:17 -05:00
Aiden Cline	5335347e80	feat(codemode): add WeakMap and WeakSet (#51257 )	2026-09-25 00:15:19 -05:00
Aiden Cline	16b18dff13	Revert "fix(core): fit model limits and recover compaction overflow" (#51273 )	2026-09-25 00:12:14 -05:00
Aiden Cline	61c2349cef	fix(core): fit model limits and recover compaction overflow (#51238 )	2026-09-25 00:11:40 -05:00
opencode-agent[bot]andBrendonovich	684721efb8	feat(app): add provider account switching (#51266 ) Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>	2026-09-25 05:03:33 +00:00
Aiden Cline	962c14a49c	fix(codemode): honor thisArg, program toString in computed keys, and ToPrimitive in String and Number arguments (#51264 )	2026-09-24 23:46:15 -05:00
opencode-agent[bot]andrekram1-node	85b98e7da4	fix(tui): handle storage watcher errors after startup (#51243 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-09-24 20:25:06 -05:00
Aiden Cline	8061220b08	test(codemode): vendor every eligible test262 directory and bound unsupported globals (#51242 )	2026-09-24 20:19:24 -05:00
Luke Parker	b02cc35f13	fix(desktop): keep browser page visible under floating content (#51240 )	2026-09-25 10:35:17 +10:00
Aiden Cline	e23d89c9a9	fix(codemode): destructure object patterns from primitives and convert Date components through ToPrimitive (#51239 )	2026-09-24 19:32:19 -05:00
ARH Alireza Haghdoost Claude Sonnet 5	e8b3e19e85	fix(tui): don't crash when fs.watch throws (e.g. ENOSPC) (#51210 ) Co-authored-by: Alireza Haghdoost <haghdoost@uber.com> Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>	2026-09-24 19:16:43 -05:00
Aiden Cline	5256f30957	feat(codemode): honor program valueOf and toString in operators and conversions (#50837 )	2026-09-24 18:45:48 -05:00