finish phase 0 of the opencode parity list

Three defects and one honest removal. Each was reproduced before being changed, as the doc asks.

B4 — images were offered and silently discarded. Every OpenCode model advertised `images: true`, the
composer gates on that flag, the bubble rendered the attachment, and `handleOpenCodeChat`'s message type
has no `images` field, so it never left officer. Flipped to false: 61 OpenCode models now decline, the
three Claude ones still accept. Plumbing them through OpenCodeRunParams stays Phase 4; advertising a
capability that does not exist is the part worth fixing today.

B5 — every OpenCode turn overwrote the previous turn's subscription handle without detaching it, so the
old session-scoped listener stayed attached and delivery doubled, tripled, and so on for any termination
that is not result/error/stopped. Deliberately NOT the Claude guard: Claude keeps one persistent session
and skips re-subscribing, while OpenCode spawns a fresh `opencode run` per turn, so a new subscription
each time is correct — detaching the old one is what was missing.

B6 — the sessionKey → `ses_…` map had no writer of deletions, so it grew for the process lifetime and a
reused key resumed a stale OpenCode session. Cleared in `deleteSession` only, never in `releaseSession`:
releasing means "let go, leave it running", and a returning browser must find the same `ses_…` again.

Phase 0 item 1 — the thinking toggle is removed rather than fixed. `thinking` is accepted on the wire
and forwarded by neither channel, so the control changed its own label and nothing else. Out of scope
for both harnesses by decision. The inert plumbing beneath it is left for a follow-up that touches the
socket contract; the props stay accepted-and-unread so no call site had to change.

Phase 0 is complete: B1, B2, B3 landed earlier; B4, B5, B6 and the selector here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/servers/api/chat/websocket.ts

@@ -438,6 +438,16 @@ async function handleOpenCodeChat(
   const onMessage = createMessageHandler(sessionId, model);
 
   try {
+    // Drop the PREVIOUS turn's listener before opening the next one.
+    //
+    // This deliberately does not mirror the Claude guard above. Claude keeps one persistent session and
+    // skips re-subscribing; OpenCode runs a fresh `opencode run` subprocess per turn, so a new
+    // subscription each time is correct. What was wrong is that the old handle was overwritten without
+    // being detached, leaving the previous session-scoped listener attached — so every turn after the
+    // first delivered doubled, tripled, and so on, for any termination that is not result/error/stopped.
+    session._sidecarUnsub?.();
+    session._sidecarUnsub = undefined;
+
     const handle = await sendOpenCodeStreaming({
       userId,
       email,