fix(message-v2): narrow SSE_STALL_MESSAGE_RE to the emitted format

The fallback regex previously allowed 'chunk timeout' / 'timeout'
variants that no caller ever emits. The only producer is wrapSSE()
in provider/provider.ts, which always emits the exact string
'SSE read timed out after Nms'. Anchors the regex and pins it to that
format with a test, so any future change to wrapSSE() format forces
a corresponding update here.

Addresses audit finding F4 (Opus diamond review, 2026-04-22).

Author: tesdal

packages/opencode/src/session/message-v2.ts

@@ -1076,9 +1076,10 @@ export const filterCompactedEffect = Effect.fnUntraced(function* (sessionID: Ses
   return filterCompacted(stream(sessionID))
 })
 
-// Legacy substring fallback for rare paths where the tagged class gets stripped
-// during cross-realm rethrow. Primary signal is `name`/`_tag` set by SSEStallError.
-const SSE_STALL_MESSAGE_RE = /SSE (read|chunk) time(d out|out)/
+// Message-based exact-match fallback for the wrapSSE() emission format.
+// The primary signal is `_tag === "SSEStallError"`; this regex only
+// matches when tag information is stripped during cross-realm rethrow.
+const SSE_STALL_MESSAGE_RE = /^SSE read timed out after \d+ms$/
 
 function hasSSEStallCause(e: unknown, depth = 0): boolean {
   if (depth > 8) return false

packages/opencode/test/session/message-v2-sse-stall.test.ts

@@ -29,14 +29,14 @@ describe("session.message-v2.fromError — SSEStallError", () => {
   })
 
   test("detects SSE stall by timeout message without SSEStallError name", () => {
-    const error = new Error("SSE chunk timeout after 120000ms")
+    const error = new Error("SSE read timed out after 120000ms")
 
     const result = MessageV2.fromError(error, { providerID })
 
     expect(result.name).toBe("SSEStallError")
     expect(MessageV2.SSEStallError.isInstance(result)).toBe(true)
     if (!MessageV2.SSEStallError.isInstance(result)) throw new Error("Expected SSEStallError")
-    expect(result.data.message).toBe("SSE chunk timeout after 120000ms")
+    expect(result.data.message).toBe("SSE read timed out after 120000ms")
   })
 
   test("detects SSE stall through two-deep cause chain", () => {
@@ -65,4 +65,44 @@ describe("session.message-v2.fromError — SSEStallError", () => {
     expect(result.name).toBe("SSEStallError")
     expect(MessageV2.APIError.isInstance(result)).toBe(false)
   })
+
+  test("hasSSEStallCause: tag-based detection still works", () => {
+    const tagged = Object.assign(new Error("anything"), { _tag: "SSEStallError" })
+    const result = MessageV2.fromError(tagged, { providerID })
+    expect(MessageV2.SSEStallError.isInstance(result)).toBe(true)
+  })
+
+  test("hasSSEStallCause: exact wrapSSE-format message is detected through cause chain", () => {
+    const taggedless = new Error("SSE read timed out after 120000ms")
+    const outer = new Error("outer")
+    outer.cause = taggedless
+    const result = MessageV2.fromError(outer, { providerID })
+    expect(MessageV2.SSEStallError.isInstance(result)).toBe(true)
+  })
+
+  test("hasSSEStallCause: message-regex fallback rejects speculative 'chunk timeout' variants", () => {
+    const speculative = new Error("SSE chunk timeout")
+    const result = MessageV2.fromError(speculative, { providerID })
+    expect(MessageV2.SSEStallError.isInstance(result)).toBe(false)
+  })
+
+  test("hasSSEStallCause: narrowed regex rejects shapes the old loose regex accepted", () => {
+    // The previous regex /SSE (read|chunk) time(d out|out)/ matched all of these;
+    // the narrowed /^SSE read timed out after \d+ms$/ rejects them all.
+    // Any future wrapSSE format change must update the regex in lockstep.
+    // Note: V8's `$` without the `m` flag is true end-of-string and does NOT
+    // match before a trailing "\n", so newline-suffixed messages are rejected.
+    const cases = [
+      "SSE read timed out", // missing "after Nms" suffix
+      "SSE chunk timed out after 120000ms", // wrong verb ("chunk" never emitted)
+      "SSE read timeout after 120000ms", // "timeout" not "timed out"
+      "prefix: SSE read timed out after 120000ms", // non-anchored prefix
+      "SSE read timed out after 120000ms ", // trailing whitespace
+      "SSE read timed out after 120000ms\n", // trailing newline ($ does not match before \n)
+    ]
+    for (const message of cases) {
+      const result = MessageV2.fromError(new Error(message), { providerID })
+      expect(MessageV2.SSEStallError.isInstance(result)).toBe(false)
+    }
+  })
 })