fix(chat): stop rendering a failed run's error twice

Every failed GJC turn puts two identical error bubbles in the
transcript. The supervisor's terminal path forwards `error` and
`complete` through the writer and then rejects the run promise, and
`handleChatSend` catches that rejection and sends a second `error`
message with a fresh id for the same failure.

Observed on the wire for one `chat.send` (2.0.0-beta.6):

  error    "GJC worker failed."  id error_7748930f-...
  complete exitCode 1
  error    "GJC worker failed."  id error_fee23e76-...

The catch now only synthesizes an error message while the run is still
running, i.e. when the runtime died without reporting anything. Once the
terminal `complete` has passed through the registry the failure is
already on screen, and the console line in the same branch keeps the
rejection visible server-side.

Tested: new websocket test drives a runtime that reports its own failure
and then rejects, and asserts the client sees exactly error + complete.

(cherry picked from commit 6a0a284)

Author: Yeachan-Heo

server/modules/websocket/services/chat-websocket.service.ts

@@ -153,7 +153,11 @@ async function sendChat(ws: WebSocket, userId: string | number | null, data: Any
     console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: message });
     const code = error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' ? error.code : null;
     if (provider === 'gjc' && code) protocolFailure(ws, code, message, sessionId);
-    else run.writer.send(createNormalizedMessage({ kind: 'error', provider, sessionId: storedSession.provider_session_id ?? sessionId, content: message }));
+    // A run that already passed its terminal `complete` reported the failure
+    // itself (GJC forwards `error` + `complete` before rejecting), so a second
+    // bubble here is the same failure rendered twice in the transcript. The
+    // console line above keeps the rejection visible server-side either way.
+    else if (run.status === 'running') run.writer.send(createNormalizedMessage({ kind: 'error', provider, sessionId: storedSession.provider_session_id ?? sessionId, content: message }));
   } finally {
     chatRunRegistry.completeRunIfCurrent(run, { exitCode: 1 });
   }

server/modules/websocket/tests/chat-websocket.service.test.ts

@@ -388,6 +388,100 @@ test('chat.send dispatches a non-Git GJC session directly in its persisted proje
   });
 });
 
+test('a runtime that reported its own failure does not get a second error bubble', async () => {
+  await withIsolatedDatabase(async () => {
+    sessionsDb.createAppSession('failing-session', 'gjc', '/workspace/failing-project');
+
+    const server = new WebSocketServer({ host: '127.0.0.1', port: 0 });
+    try {
+      await once(server, 'listening');
+      server.on('connection', (socket, request) => {
+        handleChatConnection(
+          socket,
+          Object.assign(request, { user: { id: 'test-user' } }),
+          {
+            spawnFns: {
+              // This is what the GJC supervisor does on a failed run: forward
+              // the error and the terminal complete, then reject the promise.
+              gjc: (_command, _options, writer) => {
+                const chatWriter = writer as {
+                  send(message: unknown): void;
+                  sendComplete(options: { exitCode: number }): void;
+                };
+                chatWriter.send({
+                  kind: 'error',
+                  provider: 'gjc',
+                  sessionId: 'failing-session',
+                  content: 'GJC worker failed.',
+                });
+                chatWriter.sendComplete({ exitCode: 1 });
+                return Promise.reject(new Error('GJC worker failed.'));
+              },
+            },
+            abortFns: { gjc: async () => false },
+            resolveToolApproval() {},
+            getPendingApprovalsForSession: () => [],
+          },
+        );
+      });
+
+      const address = server.address();
+      if (!address || typeof address === 'string') {
+        throw new Error('Expected the websocket test server to bind a TCP port.');
+      }
+
+      const client = new WebSocket(`ws://127.0.0.1:${address.port}`);
+      try {
+        await once(client, 'open');
+        const frames: OutboundFrame[] = [];
+        const completed = new Promise<void>((resolve, reject) => {
+          client.on('message', (raw) => {
+            try {
+              const frame = parseOutboundFrame(String(raw));
+              frames.push(frame);
+              if (frame.kind === 'complete') {
+                resolve();
+              }
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
+
+        client.send(JSON.stringify({
+          type: 'chat.send',
+          sessionId: 'failing-session',
+          content: 'fail please',
+          options: {},
+        }));
+        await completed;
+        // The rejection is handled after the terminal frame, so give the
+        // catch branch a turn before asserting nothing else arrived.
+        await flushMessages();
+        await flushMessages();
+
+        assert.deepEqual(frames.map((frame) => frame.kind), ['error', 'complete']);
+        assert.equal(frames[0]?.content, 'GJC worker failed.');
+      } finally {
+        client.terminate();
+      }
+    } finally {
+      for (const client of server.clients) {
+        client.terminate();
+      }
+      await new Promise<void>((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  });
+});
+
 test('chat.abort uses the direct GJC run handle before the app session id', async () => {
   await withIsolatedDatabase(async () => {
     sessionsDb.createAppSession('abort-session', 'gjc', '/workspace/non-git-project');