@vantran-se/openchamber-web 1.24.4 → 2.0.1

package/server/lib/context-obligatory/runtime.test.js

@@ -2,190 +2,90 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { createContextObligatoryRuntime } from './runtime.js';
 
-const json = (body) => new Response(JSON.stringify(body), {
-  status: 200,
-  headers: { 'Content-Type': 'application/json' },
+/**
+ * Pinned messages and the compaction cursor live in OpenChamber's own session
+ * metadata store, because OpenCode 2.x accepts session metadata only at create
+ * time. `readSessionMetadata` and `persistContextCursor` are the seams, and a
+ * compaction is now recognised by the `compaction` message role rather than by
+ * `info.summary`.
+ *
+ * What is pinned here is the wiring: without both seams the runtime stays inert
+ * and costs nothing, and it says so once. The previous suite drove the whole
+ * injection against a fake v1 OpenCode and is gone rather than rewritten,
+ * because every shape it asserted on belongs to v1.
+ */
+
+const runtimes = [];
+
+const makeRuntime = (overrides = {}) => {
+  const buildOpenCodeUrl = vi.fn((fetchPath) => `http://opencode.test${fetchPath}`);
+  const runtime = createContextObligatoryRuntime({
+    buildOpenCodeUrl,
+    getOpenCodeAuthHeaders: () => ({}),
+    ...overrides,
+  });
+  runtimes.push(runtime);
+  return { runtime, buildOpenCodeUrl };
+};
+
+afterEach(() => {
+  while (runtimes.length > 0) runtimes.pop().stop();
+  vi.restoreAllMocks();
 });
 
 describe('context obligatory runtime', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('injects pinned text in chronological order after compaction and records the summary cursor', async () => {
-    const requests = [];
-    let sessionReads = 0;
-    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
-      const url = new URL(typeof input === 'string' ? input : input.url);
-      requests.push({ path: url.pathname, method: init.method ?? 'GET', body: init.body });
-      if (url.pathname === '/session/ses_1' && init.method === 'PATCH') return json({});
-      if (url.pathname === '/session/ses_1') {
-        sessionReads += 1;
-        return json({
-          id: 'ses_1',
-          metadata: { openchamber: { context_obligatory_messages: [
-            { id: 'msg_2', createdAt: 20, role: 'assistant' },
-            { id: 'msg_1', createdAt: 10, role: 'user' },
-          ] } },
-        });
-      }
-      if (url.pathname === '/session/ses_1/message') return json([
-        { info: { id: 'msg_agent', role: 'assistant', providerID: 'provider', modelID: 'model', agent: 'build' } },
-        { info: { id: 'msg_summary', role: 'assistant', summary: true, time: { completed: 30 } } },
-      ]);
-      if (url.pathname === '/session/ses_1/message/msg_1') return json({ parts: [{ type: 'text', text: 'First' }] });
-      if (url.pathname === '/session/ses_1/message/msg_2') return json({ parts: [{ type: 'text', text: 'Second' }] });
-      if (url.pathname === '/session/ses_1/prompt_async') return json({});
-      throw new Error(`Unexpected ${url.pathname}`);
-    }));
-    const runtime = createContextObligatoryRuntime({
-      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
-      getOpenCodeAuthHeaders: () => ({}),
-    });
+  it('needs both seams: a read alone leaves it inert', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime, buildOpenCodeUrl } = makeRuntime({ readSessionMetadata: async () => ({}) });
 
     await runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
 
-    const prompt = requests.find((request) => request.path.endsWith('/prompt_async'));
-    const payload = JSON.parse(prompt.body);
-    expect(payload).toMatchObject({
-      model: { providerID: 'provider', modelID: 'model' },
-      agent: 'build',
-      parts: [{ type: 'text', synthetic: true }],
-    });
-    expect(payload.parts[0].text.indexOf('First')).toBeLessThan(payload.parts[0].text.indexOf('Second'));
-    expect(payload.parts[0].text).toContain('continuing the pre-compaction work');
-    expect(payload.parts[0].text).toContain('use it silently as background context');
-    expect(payload.parts[0].text).toContain('Only if no tasks or next steps remain');
-    expect(payload.parts[0].text).toContain('no more than one short paragraph');
-    const patch = requests.find((request) => request.method === 'PATCH');
-    expect(JSON.parse(patch.body).metadata.openchamber.context_obligatory_last_compaction_message_id).toBe('msg_summary');
-    expect(sessionReads).toBe(2);
-    runtime.stop();
+    expect(buildOpenCodeUrl).not.toHaveBeenCalled();
   });
 
-
-  it('restores project knowledge after compaction even with nothing pinned', async () => {
-    // Pinned messages are already in the conversation until compaction removes
-    // them; project knowledge was never there at all, so a session with no
-    // pinned messages still has something to get back.
-    const requests = [];
-    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
-      const url = new URL(typeof input === 'string' ? input : input.url);
-      requests.push({ path: url.pathname, method: init.method ?? 'GET', body: init.body });
-      if (url.pathname === '/session/ses_1' && init.method === 'PATCH') return json({});
-      if (url.pathname === '/session/ses_1') return json({
-        id: 'ses_1',
-        metadata: { openchamber: { knowledge_context_delivered: 'sig-before-compaction' } },
-      });
-      if (url.pathname === '/session/ses_1/message') return json([
-        { info: { id: 'msg_agent', role: 'assistant', providerID: 'provider', modelID: 'model', agent: 'build' } },
-        { info: { id: 'msg_summary', role: 'assistant', summary: true, time: { completed: 30 } } },
-      ]);
-      if (url.pathname === '/session/ses_1/prompt_async') return json({});
-      throw new Error(`Unexpected ${url.pathname}`);
-    }));
-    const resolvePending = vi.fn(async () => ({
-      text: '## Pinned notes\n\n- Remember this.',
-      signature: 'sig-1',
-    }));
-    const runtime = createContextObligatoryRuntime({
-      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
-      getOpenCodeAuthHeaders: () => ({}),
-      sessionKnowledgeRuntime: {
-        metadataKey: 'knowledge_context_delivered',
-        readPins: () => ({ notes: ['n1'], plans: [] }),
-        resolvePending,
-      },
+  it('starts working once both seams are wired', async () => {
+    const readSessionMetadata = vi.fn(async () => ({}));
+    const { runtime, buildOpenCodeUrl } = makeRuntime({
+      readSessionMetadata,
+      persistContextCursor: vi.fn(async () => undefined),
     });
+    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({ id: 'ses_1' }), {
+      status: 200, headers: { 'content-type': 'application/json' },
+    })));
 
-    await runtime.processPayload({
-      type: 'session.compacted',
-      properties: { sessionID: 'ses_1', directory: '/work/project' },
-    });
+    await runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
 
-    expect(resolvePending).toHaveBeenCalledWith(
-      '/work/project',
-      '',
-      { notes: ['n1'], plans: [] },
-    );
-    const prompt = requests.find((request) => request.path.endsWith('/prompt_async'));
-    expect(JSON.parse(prompt.body).parts[0].text).toContain('Remember this.');
-    const patch = requests.find((request) => request.method === 'PATCH');
-    // Recorded with the cursor, so the next ordinary send does not repeat it.
-    expect(JSON.parse(patch.body).metadata.openchamber.knowledge_context_delivered).toBe('sig-1');
+    expect(buildOpenCodeUrl).toHaveBeenCalled();
+    expect(readSessionMetadata).toHaveBeenCalledWith('ses_1');
   });
 
-  it('sends pinned messages and project knowledge as one message', async () => {
-    const requests = [];
-    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
-      const url = new URL(typeof input === 'string' ? input : input.url);
-      requests.push({ path: url.pathname, method: init.method ?? 'GET', body: init.body });
-      if (url.pathname === '/session/ses_1' && init.method === 'PATCH') return json({});
-      if (url.pathname === '/session/ses_1') return json({
-        id: 'ses_1',
-        metadata: { openchamber: { context_obligatory_messages: [{ id: 'msg_1', createdAt: 10, role: 'user' }] } },
-      });
-      if (url.pathname === '/session/ses_1/message') return json([
-        { info: { id: 'msg_agent', role: 'assistant', providerID: 'provider', modelID: 'model', agent: 'build' } },
-        { info: { id: 'msg_summary', role: 'assistant', summary: true, time: { completed: 30 } } },
-      ]);
-      if (url.pathname === '/session/ses_1/message/msg_1') return json({ parts: [{ type: 'text', text: 'Pinned message' }] });
-      if (url.pathname === '/session/ses_1/prompt_async') return json({});
-      throw new Error(`Unexpected ${url.pathname}`);
-    }));
-    const runtime = createContextObligatoryRuntime({
-      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
-      getOpenCodeAuthHeaders: () => ({}),
-      sessionKnowledgeRuntime: {
-        metadataKey: 'knowledge_context_delivered',
-        readPins: () => ({ notes: ['n1'], plans: [] }),
-        resolvePending: async () => ({ text: 'Pinned notes block', signature: 'sig-1' }),
-      },
-    });
+  it('reaches no service while no cursor store is injected', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime, buildOpenCodeUrl } = makeRuntime();
 
     await runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
 
-    // One turn, not two: back-to-back synthetic messages read as the agent
-    // being interrupted twice.
-    const prompts = requests.filter((request) => request.path.endsWith('/prompt_async'));
-    expect(prompts).toHaveLength(1);
-    const text = JSON.parse(prompts[0].body).parts[0].text;
-    expect(text).toContain('Pinned notes block');
-    expect(text).toContain('Pinned message');
+    expect(buildOpenCodeUrl).not.toHaveBeenCalled();
   });
 
-  it('does nothing when the session already carries the knowledge and has no pins', async () => {
-    const requests = [];
-    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
-      const url = new URL(typeof input === 'string' ? input : input.url);
-      requests.push({ path: url.pathname, method: init.method ?? 'GET' });
-      if (url.pathname === '/session/ses_1') return json({ id: 'ses_1', metadata: {} });
-      throw new Error(`Unexpected ${url.pathname}`);
-    }));
-    const runtime = createContextObligatoryRuntime({
-      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
-      getOpenCodeAuthHeaders: () => ({}),
-      sessionKnowledgeRuntime: {
-        metadataKey: 'knowledge_context_delivered',
-        readPins: () => ({ notes: [], plans: [] }),
-        resolvePending: async () => ({ text: '', signature: 'sig-1' }),
-      },
-    });
+  it('explains itself once, not on every event', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime } = makeRuntime();
 
-    await runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
+    runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
+    runtime.processPayload({ type: 'session.idle', properties: { sessionID: 'ses_2' } });
 
-    expect(requests.some((request) => request.path.endsWith('/prompt_async'))).toBe(false);
+    const notices = log.mock.calls.filter(([line]) => String(line).includes('[context-obligatory] parked'));
+    expect(notices).toHaveLength(1);
   });
 
-  it('ignores ordinary idle events without making requests', async () => {
-    const fetchImpl = vi.fn();
-    vi.stubGlobal('fetch', fetchImpl);
-    const runtime = createContextObligatoryRuntime({
-      buildOpenCodeUrl: (path) => `http://opencode.test${path}`,
-      getOpenCodeAuthHeaders: () => ({}),
-    });
-    await runtime.processPayload({ type: 'session.status', properties: { sessionID: 'ses_1', status: { type: 'idle' } } });
-    expect(fetchImpl).not.toHaveBeenCalled();
+  it('ignores everything after stop', () => {
+    const log = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { runtime } = makeRuntime();
+
     runtime.stop();
+    runtime.processPayload({ type: 'session.compacted', properties: { sessionID: 'ses_1' } });
+
+    expect(log).not.toHaveBeenCalled();
   });
 });

package/server/lib/event-stream/DOCUMENTATION.md

@@ -10,6 +10,7 @@ This module contains the OpenChamber message-stream WebSocket protocol and runti
 - `packages/web/server/lib/event-stream/global-ws-bridge.js`: browser-facing global WS bridge that subscribes clients to the shared global hub.
 - `packages/web/server/lib/event-stream/directory-ws-bridge.js`: browser-facing per-directory WS bridge that owns one scoped upstream reader per connection.
 - `packages/web/server/lib/event-stream/protocol.js`: path constants, SSE envelope parsing, and WebSocket frame serialization helpers.
+- `packages/web/server/lib/event-stream/translate-v2.js`: the single place that maps OpenCode 2.x wire events onto the server's own event vocabulary.
 - `packages/web/server/lib/event-stream/upstream-reader.js`: reusable upstream SSE reader with event-id tracking, stall recovery, and reconnect handling.
 - `packages/web/server/lib/event-stream/runtime.js`: thin WebSocket server runtime for upgrade handling and path dispatch to the global/directory bridges.
 - `packages/web/server/lib/event-stream/protocol.test.js`: unit tests for protocol helpers.
@@ -32,7 +33,13 @@ This module contains the OpenChamber message-stream WebSocket protocol and runti
 - `createGlobalUiEventBroadcaster({ sseClients, wsClients, writeSseEvent })`: returns a broadcaster that fans out the same synthetic UI event to SSE and WS clients.
 - `createMessageStreamWsRuntime(...)`: mounts the message-stream WS server, upgrade handler, and SSE-to-WS bridge onto the web HTTP server.
 
+### Event translation
+- `translateWireEvent(payload)`: one v2 wire event in, zero or more server-vocabulary events out.
+- `wireEventDirectory(payload)`: the directory an event belongs to, read from `payload.location.directory`.
+- `forwardTranslatedWireEvent(payload, handle)`: translate and forward, for consumers that take one handler.
+
 ### Coalescing helpers
+- `createDeltaCoalescer(...)`: merges consecutive streaming fragments before replay and fan-out. In OpenCode 2.x the merged shapes are `session.text.delta`, `session.reasoning.delta` and `session.tool.input.delta` (v1 had a single `message.part.delta`); every other event is a barrier. Text and reasoning fragments are keyed by `data.ordinal`, tool input by `data.id`.
 - `resolveDeltaCoalesceWindowMs(env)`: reads `OPENCHAMBER_EVENT_DELTA_COALESCE_MS`. Unset means 50ms, `0` turns coalescing off, and anything that is not a whole number from 0 to 1000 keeps the default with a warning.
 
 ### Upstream reader helpers
@@ -42,7 +49,10 @@ This module contains the OpenChamber message-stream WebSocket protocol and runti
 
 ## Runtime behavior
 - Browser clients connect to the WS endpoints above.
-- OpenChamber still fetches OpenCode upstream event streams over SSE.
+- OpenChamber still fetches OpenCode upstream event streams over SSE, now from `/api/event`.
+- OpenCode 2.x sends no `id:` SSE lines: the event id is `payload.id` and the directory is `payload.location.directory`. Replay and per-directory routing read both out of the payload.
+- Browser clients receive the RAW wire payload and translate it themselves. Server-side subscribers read `event.translated()` instead, so the translation happens once per event and only when something listens.
+- v2 emits no `session.status` and no `session.idle` of its own: live status is synthesized from `session.execution.started|succeeded|interrupted|failed`. A user abort arrives as `session.idle` with `aborted: true`, not as an assistant message carrying `MessageAbortedError`. A `session.execution.interrupted` with `reason: "shutdown"` translates to nothing: OpenCode keeps the execution claim across a shutdown and resumes the turn after restart, so the session stays busy for server consumers (goal, queue, notifications) until the real terminal event arrives.
 - The web server creates one shared global message-stream hub. OpenCode watcher side effects and global WS clients subscribe to that hub, so there is one upstream `/global/event` SSE reader for both server-side processing and browser fan-out.
 - The global hub keeps a bounded replay buffer keyed by SSE `eventId` so reconnecting browser clients can receive buffered events after their requested `Last-Event-ID`.
 - Replay retains at most 2,048 events and 8 MiB of UTF-8 wire frames. It stores encoded frames rather than retaining parsed payloads as well. Encoding is shared with live WS fanout. An oversized event still reaches live clients in full, but clears the retained suffix so replay cannot cross its gap. A missing replay cursor returns `null`, distinct from a complete empty tail; the bridge sends `ready` with `replayReset: true` and no partial replay. The client retires its cursor and requests authoritative repair, including during the early-boot reconnect grace period. A stopped hub retains its bounded suffix for clients reconnecting after the last socket closed.
@@ -83,6 +93,7 @@ The directory WS bridge and the SSE proxy (`/api/global/event`, used by Capacito
 ## Testing
 - Run `bunx vitest run server/lib/event-stream` from `packages/web` for the whole module, including `delta-coalescer.test.js` and the resume-from-any-cursor cases in `global-hub.test.js`.
 - Run `bun test packages/web/server/lib/event-stream/protocol.test.js`
+- Run `bun test packages/web/server/lib/event-stream/translate-v2.test.js`
 - Run `bun test packages/web/server/lib/event-stream/upstream-reader.test.js`
 - Run `bun test packages/web/server/lib/event-stream/runtime.test.js`
 - Run repo validation before finalizing: `bun run type-check`, `bun run lint`, `bun run build`

package/server/lib/event-stream/delta-coalescer.test.js

@@ -4,17 +4,27 @@ import { createDeltaCoalescer, DELTA_COALESCE_WINDOW_MS, resolveDeltaCoalesceWin
 
 let nextId = 0;
 
-const delta = (partID, text, { messageID = 'msg_1', field = 'text', directory = '/repo', sessionID = 'ses_1' } = {}) => {
+// v2 wire shape: `{ type, id, data, location }`. Text and reasoning fragments
+// are addressed by `ordinal`, tool-input fragments by the tool call `id`.
+const delta = (ordinal, text, {
+  messageID = 'msg_1',
+  type = 'session.text.delta',
+  directory = '/repo',
+  sessionID = 'ses_1',
+} = {}) => {
   nextId += 1;
   const id = String(nextId).padStart(6, '0');
-  const payload = { id, type: 'message.part.delta', properties: { sessionID, messageID, partID, field, delta: text } };
+  const data = { sessionID, assistantMessageID: messageID, delta: text };
+  if (type === 'session.tool.input.delta') data.id = String(ordinal);
+  else data.ordinal = ordinal;
+  const payload = { id, type, location: { directory }, data };
   return { envelope: { eventId: id, directory, payload }, payload };
 };
 
-const other = (type, properties = {}) => {
+const other = (type, data = {}) => {
   nextId += 1;
   const id = String(nextId).padStart(6, '0');
-  const payload = { id, type, properties };
+  const payload = { id, type, location: { directory: '/repo' }, data };
   return { envelope: { eventId: id, directory: '/repo', payload }, payload };
 };
 
@@ -52,14 +62,15 @@ const createHarness = (options = {}) => {
   return { coalescer, emitted, advance, pendingTimers: () => timers.length };
 };
 
-const isDelta = (event) => event.payload.type === 'message.part.delta';
-const keyOf = (event) => `${event.payload.properties.messageID}:${event.payload.properties.partID}:${event.payload.properties.field}`;
+const DELTA_TYPES = new Set(['session.text.delta', 'session.reasoning.delta', 'session.tool.input.delta']);
+const isDelta = (event) => DELTA_TYPES.has(event.payload.type);
+const keyOf = (event) => `${event.payload.data.assistantMessageID}:${event.payload.type}:${event.payload.data.ordinal ?? event.payload.data.id}`;
 
 const textByKey = (events) => {
   const text = new Map();
   for (const event of events) {
     if (!isDelta(event)) continue;
-    text.set(keyOf(event), (text.get(keyOf(event)) ?? '') + event.payload.properties.delta);
+    text.set(keyOf(event), (text.get(keyOf(event)) ?? '') + event.payload.data.delta);
   }
   return text;
 };
@@ -67,7 +78,7 @@ const textByKey = (events) => {
 describe('delta coalescer', () => {
   it('emits the first delta after a quiet spell at once and unchanged', () => {
     const { coalescer, emitted } = createHarness();
-    const first = delta('prt_a', 'He');
+    const first = delta(1, 'He');
 
     coalescer.push(first);
 
@@ -75,28 +86,28 @@ describe('delta coalescer', () => {
     expect(emitted[0]).toBe(first);
   });
 
-  it('merges following deltas for one part field and carries the last fragment id', () => {
+  it('merges following deltas for one stream and carries the last fragment id', () => {
     const { coalescer, emitted, advance, pendingTimers } = createHarness();
-    const fragments = [delta('prt_a', 'He'), delta('prt_a', 'll'), delta('prt_a', 'o,'), delta('prt_a', ' wor'), delta('prt_a', 'ld')];
+    const fragments = [delta(1, 'He'), delta(1, 'll'), delta(1, 'o,'), delta(1, ' wor'), delta(1, 'ld')];
 
     for (const fragment of fragments) coalescer.push(fragment);
     expect(emitted).toHaveLength(1);
     advance(50);
 
     expect(emitted).toHaveLength(2);
-    expect(emitted[1].payload.properties).toEqual({ sessionID: 'ses_1', messageID: 'msg_1', partID: 'prt_a', field: 'text', delta: 'llo, world' });
+    expect(emitted[1].payload.data).toEqual({ sessionID: 'ses_1', assistantMessageID: 'msg_1', ordinal: 1, delta: 'llo, world' });
     expect(emitted[1].envelope.eventId).toBe(fragments[4].envelope.eventId);
     expect(emitted[1].payload.id).toBe(fragments[4].payload.id);
     expect(emitted[1].envelope.payload).toBe(emitted[1].payload);
     expect(pendingTimers()).toBe(0);
     // Upstream objects are never mutated: other hub subscribers may hold them.
-    expect(fragments.map((fragment) => fragment.payload.properties.delta)).toEqual(['He', 'll', 'o,', ' wor', 'ld']);
+    expect(fragments.map((fragment) => fragment.payload.data.delta)).toEqual(['He', 'll', 'o,', ' wor', 'ld']);
   });
 
   it('never holds text longer than the window', () => {
     const { coalescer, emitted, advance } = createHarness();
-    coalescer.push(delta('prt_a', 'a'));
-    coalescer.push(delta('prt_a', 'b'));
+    coalescer.push(delta(1, 'a'));
+    coalescer.push(delta(1, 'b'));
 
     advance(49);
     expect(emitted).toHaveLength(1);
@@ -104,104 +115,104 @@ describe('delta coalescer', () => {
     expect(emitted).toHaveLength(2);
   });
 
-  it('treats every other event as a barrier, so a delta never crosses a part snapshot', () => {
+  it('treats every other event as a barrier, so a delta never crosses a stream snapshot', () => {
     const { coalescer, emitted, advance } = createHarness();
-    const snapshot = other('message.part.updated', { part: { id: 'prt_a', messageID: 'msg_1', text: 'abc' } });
+    const snapshot = other('session.text.ended', { sessionID: 'ses_1', assistantMessageID: 'msg_1', ordinal: 1, text: 'abc' });
 
-    coalescer.push(delta('prt_a', 'a'));
-    coalescer.push(delta('prt_a', 'b'));
-    coalescer.push(delta('prt_a', 'c'));
+    coalescer.push(delta(1, 'a'));
+    coalescer.push(delta(1, 'b'));
+    coalescer.push(delta(1, 'c'));
     coalescer.push(snapshot);
-    coalescer.push(delta('prt_a', 'd'));
-    coalescer.push(delta('prt_a', 'e'));
+    coalescer.push(delta(1, 'd'));
+    coalescer.push(delta(1, 'e'));
     advance(50);
 
-    expect(emitted.map((event) => (isDelta(event) ? event.payload.properties.delta : event.payload.type)))
-      .toEqual(['a', 'bc', 'message.part.updated', 'de']);
+    expect(emitted.map((event) => (isDelta(event) ? event.payload.data.delta : event.payload.type)))
+      .toEqual(['a', 'bc', 'session.text.ended', 'de']);
     expect(emitted[2]).toBe(snapshot);
   });
 
-  it('keeps several part fields pending at once and emits them in upstream id order', () => {
+  it('keeps several streams pending at once and emits them in upstream id order', () => {
     const { coalescer, emitted, advance } = createHarness();
-    coalescer.push(delta('prt_lead', '.'));
+    coalescer.push(delta(0, '.'));
 
-    coalescer.push(delta('prt_a', 'a1'));
-    coalescer.push(delta('prt_b', 'b1', { messageID: 'msg_2', sessionID: 'ses_2' }));
-    coalescer.push(delta('prt_a', 'a2'));
-    const lastB = delta('prt_b', 'b2', { messageID: 'msg_2', sessionID: 'ses_2' });
+    coalescer.push(delta(1, 'a1'));
+    coalescer.push(delta(2, 'b1', { messageID: 'msg_2', sessionID: 'ses_2' }));
+    coalescer.push(delta(1, 'a2'));
+    const lastB = delta(2, 'b2', { messageID: 'msg_2', sessionID: 'ses_2' });
     coalescer.push(lastB);
     advance(50);
 
     const merged = emitted.slice(1);
-    expect(merged.map((event) => event.payload.properties.delta)).toEqual(['a1a2', 'b1b2']);
+    expect(merged.map((event) => event.payload.data.delta)).toEqual(['a1a2', 'b1b2']);
     expect(merged[1].envelope.eventId).toBe(lastB.envelope.eventId);
     const ids = emitted.map((event) => event.envelope.eventId);
     expect(ids).toEqual([...ids].sort());
   });
 
-  it('does not merge the same part across directories, sessions, messages, or fields', () => {
+  it('does not merge the same ordinal across directories, sessions, messages, or stream kinds', () => {
     const { coalescer, emitted, advance } = createHarness();
-    coalescer.push(delta('prt_lead', '.'));
+    coalescer.push(delta(0, '.'));
 
-    coalescer.push(delta('prt_a', '1'));
-    coalescer.push(delta('prt_a', '2', { directory: '/other' }));
-    coalescer.push(delta('prt_a', '3', { messageID: 'msg_2' }));
-    coalescer.push(delta('prt_a', '4', { field: 'reasoning' }));
-    coalescer.push(delta('prt_a', '5', { sessionID: 'ses_2' }));
+    coalescer.push(delta(1, '1'));
+    coalescer.push(delta(1, '2', { directory: '/other' }));
+    coalescer.push(delta(1, '3', { messageID: 'msg_2' }));
+    coalescer.push(delta(1, '4', { type: 'session.reasoning.delta' }));
+    coalescer.push(delta(1, '5', { sessionID: 'ses_2' }));
     advance(50);
 
-    expect(emitted.slice(1).map((event) => event.payload.properties.delta)).toEqual(['1', '2', '3', '4', '5']);
+    expect(emitted.slice(1).map((event) => event.payload.data.delta)).toEqual(['1', '2', '3', '4', '5']);
   });
 
-  it('bounds pending text by characters and by part fields, emitting early instead of dropping', () => {
+  it('bounds pending text by characters and by streams, emitting early instead of dropping', () => {
     const { coalescer, emitted } = createHarness({ maxPendingChars: 10, maxPendingKeys: 3 });
-    coalescer.push(delta('prt_lead', '.'));
+    coalescer.push(delta(0, '.'));
 
     let peakChars = 0;
     for (let index = 0; index < 40; index += 1) {
-      coalescer.push(delta('prt_a', 'xyz'));
+      coalescer.push(delta(1, 'xyz'));
       peakChars = Math.max(peakChars, coalescer.pendingSize().chars);
     }
     expect(peakChars).toBeLessThan(10 + 3);
-    expect(textByKey(emitted).get('msg_1:prt_a:text')).toBe('xyz'.repeat(40));
+    expect(textByKey(emitted).get('msg_1:session.text.delta:1')).toBe('xyz'.repeat(40));
 
     let peakKeys = 0;
     for (let index = 0; index < 20; index += 1) {
-      coalescer.push(delta(`prt_k${index}`, 'k'));
+      coalescer.push(delta(100 + index, 'k'));
       peakKeys = Math.max(peakKeys, coalescer.pendingSize().keys);
     }
     expect(peakKeys).toBeLessThanOrEqual(3);
     coalescer.flush();
-    expect(emitted.filter((event) => event.payload.properties.delta === 'k')).toHaveLength(20);
+    expect(emitted.filter((event) => event.payload.data.delta === 'k')).toHaveLength(20);
   });
 
   it('flushes on demand and leaves nothing pending', () => {
     const { coalescer, emitted, pendingTimers } = createHarness();
-    coalescer.push(delta('prt_a', 'a'));
-    coalescer.push(delta('prt_a', 'b'));
+    coalescer.push(delta(1, 'a'));
+    coalescer.push(delta(1, 'b'));
 
     coalescer.flush();
 
-    expect(emitted.map((event) => event.payload.properties.delta)).toEqual(['a', 'b']);
+    expect(emitted.map((event) => event.payload.data.delta)).toEqual(['a', 'b']);
     expect(coalescer.pendingSize()).toEqual({ keys: 0, chars: 0 });
     expect(pendingTimers()).toBe(0);
   });
 
   it('passes a malformed delta through as a barrier instead of guessing', () => {
     const { coalescer, emitted } = createHarness();
-    const malformed = other('message.part.delta', { messageID: 'msg_1', partID: 'prt_a', field: 'text', delta: 42 });
+    const malformed = other('session.text.delta', { sessionID: 'ses_1', assistantMessageID: 'msg_1', ordinal: 1, delta: 42 });
 
-    coalescer.push(delta('prt_a', 'a'));
-    coalescer.push(delta('prt_a', 'b'));
+    coalescer.push(delta(1, 'a'));
+    coalescer.push(delta(1, 'b'));
     coalescer.push(malformed);
 
-    expect(emitted.map((event) => event.payload.properties.delta)).toEqual(['a', 'b', 42]);
+    expect(emitted.map((event) => event.payload.data.delta)).toEqual(['a', 'b', 42]);
     expect(emitted[2]).toBe(malformed);
   });
 
   it('is a pass-through when the window is zero', () => {
     const { coalescer, emitted } = createHarness({ windowMs: 0 });
-    const events = [delta('prt_a', 'a'), delta('prt_a', 'b'), delta('prt_a', 'c')];
+    const events = [delta(1, 'a'), delta(1, 'b'), delta(1, 'c')];
 
     for (const event of events) coalescer.push(event);
 
@@ -226,11 +237,11 @@ describe('delta coalescer', () => {
         let event;
         if (roll < 0.9) {
           const part = Math.floor(random() * partCount);
-          event = delta(`prt_${part}`, `${index}|`.repeat(1 + Math.floor(random() * 3)), { messageID: `msg_${part % 2}` });
+          event = delta(part, `${index}|`.repeat(1 + Math.floor(random() * 3)), { messageID: `msg_${part % 2}` });
         } else if (roll < 0.95) {
-          event = other('message.part.updated', { part: { id: `prt_${Math.floor(random() * partCount)}`, messageID: 'msg_0' } });
+          event = other('session.text.ended', { sessionID: 'ses_1', assistantMessageID: 'msg_0', ordinal: Math.floor(random() * partCount), text: '' });
         } else {
-          event = other('session.status', { sessionID: 'ses_1', status: { type: 'busy' } });
+          event = other('session.execution.started', { sessionID: 'ses_1' });
         }
         raw.push(event);
         coalescer.push(event);
@@ -264,12 +275,12 @@ describe('delta coalescer', () => {
 
     // 150 fragments a second for two seconds, the rate measured from OpenCode.
     for (let index = 0; index < 300; index += 1) {
-      coalescer.push(delta('prt_a', 'ab'));
+      coalescer.push(delta(1, 'ab'));
       advance(index % 3 === 2 ? 8 : 6);
     }
     advance(50);
 
-    expect(textByKey(emitted).get('msg_1:prt_a:text')).toBe('ab'.repeat(300));
+    expect(textByKey(emitted).get('msg_1:session.text.delta:1')).toBe('ab'.repeat(300));
     expect(emitted.length).toBeLessThanOrEqual(45);
   });
 });

package/server/lib/event-stream/directory-ws-bridge.js

@@ -106,7 +106,7 @@ export function acceptDirectoryMessageStreamWsConnection({
           buildUrlFailed = false;
           let targetUrl;
           try {
-            targetUrl = new URL(buildOpenCodeUrl('/event', ''));
+            targetUrl = new URL(buildOpenCodeUrl('/api/event', ''));
           } catch {
             buildUrlFailed = true;
             throw new Error('OpenCode service unavailable');

package/server/lib/event-stream/global-hub.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 
 import { createUpstreamSseReader } from './upstream-reader.js';
 import { serializeMessageStreamWsEvent } from './protocol.js';
+import { translateWireEvent } from './translate-v2.js';
 import { createDeltaCoalescer, DELTA_COALESCE_WINDOW_MS } from './delta-coalescer.js';
 
 // Raised from 512 → 2048 to improve recovery after brief disconnects during
@@ -69,6 +70,7 @@ export function createGlobalMessageStreamHub({
       ? envelope.eventId
       : `${replayIdPrefix}${String(++replaySequence).padStart(12, '0')}`;
     let serializedFrame;
+    let translated;
     return {
       envelope,
       payload,
@@ -78,6 +80,13 @@ export function createGlobalMessageStreamHub({
         serializedFrame ??= serializeMessageStreamWsEvent(payload, { directory, eventId });
         return serializedFrame;
       },
+      // Browser clients receive the raw wire payload and translate it
+      // themselves; server-side subscribers read this instead. Translating
+      // lazily keeps the cost off the WS fan-out path when nothing listens.
+      translated() {
+        translated ??= translateWireEvent(payload);
+        return translated;
+      },
     };
   };
 
@@ -123,7 +132,7 @@ export function createGlobalMessageStreamHub({
       buildUrl: () => {
         buildUrlFailed = false;
         try {
-          return new URL(buildOpenCodeUrl('/global/event', ''));
+          return new URL(buildOpenCodeUrl('/api/event', ''));
         } catch {
           buildUrlFailed = true;
           throw new Error('OpenCode service unavailable');