@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.10

package/server/lib/session-title/session-access.test.js

@@ -0,0 +1,91 @@
+import { beforeEach, expect, it, vi } from 'vitest';
+import { mergeMetadataPatch } from '../session-metadata/session-metadata-store.js';
+
+const { api } = vi.hoisted(() => ({ api: {
+  session: { get: vi.fn(), update: vi.fn() },
+  message: { list: vi.fn() },
+} }));
+vi.mock('../opencode/v2-client.js', () => ({ makeOpenCodeV2Client: () => api }));
+import { createTitleSessionAccess } from './session-access.js';
+
+beforeEach(() => vi.resetAllMocks());
+
+function fixture() {
+  let metadata = { openchamber: {
+    goal: { status: 'active' },
+    titleRefresh: { isGenerating: true, requestedAt: 1000, lastError: 'old failure', failedAt: 1 },
+  } };
+  api.session.get.mockResolvedValue({
+    id: 'ses_title', title: 'Updated title', location: { directory: '/repo' },
+    time: { created: 10, updated: 20 },
+  });
+  const persist = vi.fn(async (_id, patch) => { metadata = mergeMetadataPatch(metadata, patch); });
+  const publish = vi.fn();
+  const access = createTitleSessionAccess({
+    buildOpenCodeUrl: (path) => `http://opencode${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    readSessionMetadata: async () => metadata,
+    persistSessionMetadata: persist,
+    publishSession: publish,
+  });
+  return { access, persist, publish, metadata: () => metadata };
+}
+
+it('publishes the full authoritative title row and clears Host loading without overwriting unrelated state', async () => {
+  const f = fixture();
+  await f.access.update('ses_title', '/repo', {
+    title: 'Updated title',
+    metadata: { openchamber: { goal: { status: 'stale' }, titleRefresh: {
+      lastAutoTitle: 'Updated title', isGenerating: null, requestedAt: null, lastError: null, failedAt: null,
+    } } },
+  });
+  expect(api.session.update.mock.calls[0][0]).toEqual({ sessionID: 'ses_title', title: 'Updated title' });
+  expect(f.metadata()).toEqual({ openchamber: {
+    goal: { status: 'active' }, titleRefresh: { lastAutoTitle: 'Updated title' },
+  } });
+  expect(f.publish).toHaveBeenCalledWith(expect.objectContaining({
+    id: 'ses_title', title: 'Updated title', directory: '/repo', metadata: f.metadata(),
+  }), '/repo');
+});
+
+it('projects only the bounded newest message page in conversation order', async () => {
+  const f = fixture();
+  api.message.list.mockResolvedValue({ data: [
+    { id: 'a1', type: 'assistant', content: [{ type: 'text', text: 'Finished' }] },
+    { id: 'u1', type: 'user', text: 'Implement title refresh' },
+  ] });
+  const messages = await f.access.messages('ses_title', '/repo', 16);
+  expect(api.message.list.mock.calls[0][0]).toEqual({ sessionID: 'ses_title', limit: 16, order: 'desc' });
+  expect(messages.map((row) => row.info.id)).toEqual(['u1', 'a1']);
+  expect(messages[0].parts[0].text).toBe('Implement title refresh');
+  expect(messages[1].parts[0].text).toBe('Finished');
+});
+
+it('publishes a full loading row before the new session exists in client catalogs', async () => {
+  const f = fixture();
+  await f.access.update('ses_title', '/repo', { metadata: { openchamber: { titleRefresh: { isGenerating: true } } } });
+  expect(f.publish).toHaveBeenCalledWith(expect.objectContaining({
+    id: 'ses_title', directory: '/repo', metadata: expect.objectContaining({
+      openchamber: expect.objectContaining({ titleRefresh: expect.objectContaining({ isGenerating: true }) }),
+    }),
+  }), '/repo');
+  expect(api.session.update).not.toHaveBeenCalled();
+});
+
+it('does not publish success on a failed title write', async () => {
+  const f = fixture();
+  api.session.update.mockRejectedValue(new Error('offline'));
+  await expect(f.access.update('ses_title', '/repo', {
+    title: 'Failed', metadata: { openchamber: { titleRefresh: { lastAutoTitle: 'Failed' } } },
+  })).rejects.toThrow('offline');
+  expect(f.persist).not.toHaveBeenCalled();
+  expect(f.publish).not.toHaveBeenCalled();
+});
+
+it('does not turn a failed or malformed message read into empty success', async () => {
+  const f = fixture();
+  api.message.list.mockRejectedValueOnce(new Error('offline'));
+  await expect(f.access.messages('ses_title', '/repo', 16)).rejects.toThrow('offline');
+  api.message.list.mockResolvedValueOnce({});
+  await expect(f.access.messages('ses_title', '/repo', 16)).rejects.toThrow('invalid message page');
+});

package/server/lib/session-turn-pages/DOCUMENTATION.md

@@ -4,7 +4,7 @@
 
 OpenChamber-owned turn-window pagination and anchor reconcile for session messages.
 
-1. **Turn pages** — clients request the last N **authored user turns** (default 3) rather than a raw message count. The host loops official OpenCode `session.messages` pages (`limit` / `before` / `x-next-cursor`) until the turn budget is met or history is exhausted.
+1. **Turn pages** — clients request the last N **authored user turns** (default 3) rather than a raw message count. The host loops OpenCode v2 `message.list` pages (first page `limit` + `order=desc`; continuation `limit` + `cursor` from the previous body `cursor.next` — upstream rejects `order` together with `cursor` with 400) until the turn budget is met or history is exhausted.
 2. **Anchor reconcile** — after SSE reconnect, clients request the gap from a stable turn-boundary anchor to the current head. The host scans newest→older, returns chronological gap records (including the anchor's overlap turn), and paginates via host-owned continuation tokens with page/byte/total budgets.
 
 Exposed as:
@@ -16,7 +16,7 @@ Exposed as:
 
 ## Why this exists
 
-Official OpenCode pagination is message-count based and uses **opaque** cursors (not message ids). Each upstream page is chronological **old→new** (including the latest slice). UI prepend/load-more needs a stable turn boundary so synthetic loop messages, subtasks, and compaction rows do not consume the turn budget. This module aggregates upstream pages on the host, returns chronological records, and exposes a continuous **host-owned opaque cursor** that points just before the earliest returned authored user.
+Official OpenCode pagination is message-count based and uses **opaque** cursors (not message ids). v2 pages arrive **newest-first**; `fetchPage` reverses each page to chronological **old→new** before aggregation. UI prepend/load-more needs a stable turn boundary so synthetic loop messages, subtasks, and compaction rows do not consume the turn budget. This module aggregates upstream pages on the host, returns chronological records, and exposes a continuous **host-owned opaque cursor** that points just before the earliest returned authored user.
 
 ## Scope
 
@@ -66,7 +66,7 @@ Success `200`:
 }
 ```
 
-- `records`: chronological oldest → newest, including intermediate non-boundary rows (synthetic, tools, subtask, compaction) inside the window.
+- `records`: chronological oldest → newest, including intermediate non-boundary rows (synthetic, tools, subtask, compaction) inside the window. Host projection drops v2 **control** SessionMessage rows (`idle`, `model-switched`, `agent-selected`, `agent-switched`, `location-switched`) so they never reach ChatMessage as empty Assistant headers. Native assistants project `content[]` once (never also top-level `text` when `content` is present). Wire `model.id` becomes domain `modelID`; `finish`/`error` on failed assistants (e.g. `provider.auth` 401) are preserved.
 - `turnCount`: count of authored user boundaries in `records`.
 - `cursor`: host-owned opaque token for the next `before=` request; `null` when `complete` is true. The token represents the position **just before** the earliest returned authored user (so the client can load older history without overlap).
 - `complete`: `upstreamComplete && selected.length === accumulated.length`. True when upstream history is exhausted **and** `selectTurnRecords` did not trim any older scanned rows (nothing left for the client). When the scan window held more than N turns and older rows were trimmed, or when upstream stopped on a full page with a missing `nextCursor` (suspicious truncation), `complete` stays `false` with a `cursor` so the client can fetch / retry.
@@ -126,7 +126,7 @@ On resume:
 1. Strict decode / shape / length validation of the host token.
 2. First `fetchPage` uses the token’s raw upstream `before`.
 3. Locate `boundaryID` in that page; keep only records strictly older than it (`slice(0, index)` in old→new order). Boundary and newer rows are excluded.
-4. If fewer than N turns remain, continue with that raw page’s `x-next-cursor` for older pages.
+4. If fewer than N turns remain, continue with that raw page’s `cursor.next` for older pages.
 5. Each accumulated record records its upstream page’s request-before origin; when `complete=false`, the next host cursor encodes the earliest selected authored user’s origin + id.
 
 A raw OpenCode SDK cursor (no `oc1.` prefix) is still accepted as the first `before` and is passed through unchanged to `fetchPage`.
@@ -146,14 +146,15 @@ A message is an authored user turn boundary when:
 
 ## Aggregation rules
 
-- Upstream pages are chronological **old→new** within each page; **do not reverse**. Older pages are **prepended** while deduping by `info.id` (global order remains old→new).
-- Continues paging with raw upstream `before` until `turns` authored boundaries are collected or upstream reports no next cursor.
-- **Suspicious truncation:** an upstream page whose `records.length >= scanLimit` (full page) but `nextCursor == null` is treated as a non-authoritative cut (observed OpenCode `x-next-cursor` race), not as end-of-history. The host stops scanning that round with `upstreamComplete=false`, so the response stays `complete=false` and still emits a boundary host cursor the client can retry. A short page (`records.length < scanLimit`) with no cursor, an empty page with no cursor, or an explicit `page.complete === true` remain authoritative exhaustion. Client no-growth handling still bounds retries if the upstream view stays truncated.
+- `fetchPage` returns each page chronological **old→new** (v2 `data` is newest-first and is reversed there). Older pages are **prepended** while deduping by `info.id` (global order remains old→new).
+- Continues paging with the raw upstream `cursor.next` (sent as `cursor`, never with `order`) until `turns` authored boundaries are collected or upstream reports no next cursor.
+- **Suspicious truncation:** an upstream page whose `records.length >= scanLimit` (full page) but `nextCursor == null` is treated as a non-authoritative cut (observed OpenCode next-cursor race), not as end-of-history. The host stops scanning that round with `upstreamComplete=false`, so the response stays `complete=false` and still emits a boundary host cursor the client can retry. A short page (`records.length < scanLimit`) with no cursor, an empty page with no cursor, or an explicit `page.complete === true` remain authoritative exhaustion. Client no-growth handling still bounds retries if the upstream view stays truncated.
 - Every upstream record must have a non-empty `info.id`; otherwise structured error, no partial `records`, HTTP 502.
 - Hard scan caps (no partial success): **50 pages** / **5000 messages** → structured error, HTTP 413.
 - Repeated / stalled cursor, or empty page that still carries a next cursor → structured error, no partial `records`, HTTP 502.
 - Malformed upstream payloads and SDK/transport failures → HTTP 502 (`error: "upstream"`).
-- `AbortSignal` is forwarded to each `session.messages` call; route also applies a 45s linked timeout.
+- Native v2 `SessionMessageInfo` rows are projected to the external `{ info, parts }` record contract by `session-message-projection.js` (control rows such as `idle` / `model-switched` are dropped). The VS Code turn-page bridge imports the same module so both runtimes emit identical records.
+- `AbortSignal` is forwarded to each `message.list` call; route also applies a 45s linked timeout.
 - Request abort only when the client disconnects mid-flight: `req` aborted, or `res` `close` while `!res.writableEnded`. A normal GET request `close` after the response has ended must not abort.
 
 ## Anchor reconcile API

package/server/lib/session-turn-pages/routes.js

@@ -18,6 +18,10 @@ import {
   projectSlimParts,
   SLIM_PARTS_PROJECTION,
 } from './service.js';
+import {
+  projectSessionMessage,
+  projectSessionMessageRecords as projectRecords,
+} from './session-message-projection.js';
 
 const TURNS_MIN = 1;
 const TURNS_MAX = 10;
@@ -210,103 +214,6 @@ const requestSignal = (req, res) => {
   return controller.signal;
 };
 
-/**
- * Native SessionMessageInfo carrier fields that become `parts`.
- * Must not remain on `info` after normalize — otherwise
- * includeReasoning=false can strip parts while leaking content/text.
- */
-const MESSAGE_PART_CARRIER_KEYS = new Set(['content', 'text', 'files', 'parts', 'agents', 'skills']);
-
-const stripMessagePartCarriers = (value) => {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
-  let changed = false;
-  const next = {};
-  for (const [key, field] of Object.entries(value)) {
-    if (MESSAGE_PART_CARRIER_KEYS.has(key)) {
-      changed = true;
-      continue;
-    }
-    next[key] = field;
-  }
-  return changed ? next : value;
-};
-
-/**
- * Project SessionMessageInfo (or an already-projected {info, parts} row)
- * into the host HTTP DTO. External route contract stays {info, parts}.
- */
-const projectV2Parts = (entry) => {
-  if (Array.isArray(entry?.parts)) return entry.parts;
-  const messageID = typeof entry?.id === 'string' ? entry.id : '';
-  const sessionID = typeof entry?.sessionID === 'string' ? entry.sessionID : '';
-  const parts = [];
-  if (typeof entry?.text === 'string' && entry.text) {
-    parts.push({ id: `${messageID}:text`, sessionID, messageID, type: 'text', text: entry.text });
-  }
-  if (Array.isArray(entry?.files)) {
-    entry.files.forEach((file, index) => {
-      parts.push({
-        id: `${messageID}:file:${index}`,
-        sessionID,
-        messageID,
-        type: 'file',
-        mime: file?.mime || 'application/octet-stream',
-        url: file?.uri ?? file?.url,
-        ...(file?.name ? { filename: file.name } : {}),
-      });
-    });
-  }
-  if (Array.isArray(entry?.content)) {
-    entry.content.forEach((item, index) => {
-      const partID = item?.id || `${messageID}:content:${index}`;
-      if (item?.type === 'text') {
-        parts.push({ id: partID, sessionID, messageID, type: 'text', text: item.text ?? '' });
-      } else if (item?.type === 'reasoning') {
-        parts.push({ id: partID, sessionID, messageID, type: 'reasoning', text: item.text ?? '' });
-      } else if (item?.type === 'tool') {
-        parts.push({
-          id: partID,
-          sessionID,
-          messageID,
-          type: 'tool',
-          tool: item.name,
-          callID: item.id,
-          state: item.state ?? {},
-        });
-      }
-    });
-  }
-  return parts;
-};
-
-const projectSessionMessage = (entry) => {
-  if (entry && typeof entry === 'object' && entry.info && typeof entry.info === 'object') {
-    const info = stripMessagePartCarriers(entry.info);
-    return {
-      info: info === entry.info ? entry.info : info,
-      parts: Array.isArray(entry.parts) ? entry.parts : [],
-    };
-  }
-  if (!entry || typeof entry !== 'object' || typeof entry.id !== 'string' || entry.id.length === 0) {
-    return entry;
-  }
-  const role = entry.type === 'user' || entry.type === 'assistant' ? entry.type : (entry.role ?? entry.type);
-  const info = {
-    ...stripMessagePartCarriers(entry),
-    id: entry.id,
-    sessionID: entry.sessionID,
-    role,
-    time: entry.time ?? { created: 0 },
-  };
-  return {
-    info,
-    parts: projectV2Parts(entry),
-  };
-};
-
-const projectRecords = (records) =>
-  (Array.isArray(records) ? records : []).map(projectSessionMessage);
-
 /**
  * Host outbound order: normalize → slim/L1 bounds → reasoning strip.
  * Slim/reasoning must run on `{info, parts}` so native `content` cannot
@@ -327,11 +234,12 @@ const createV2FetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
     const headers = typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {};
     const client = makeOpenCodeV2Client({ baseUrl, authHeaders: headers });
 
+    // Upstream rejects `order` together with `cursor` (400); the cursor
+    // already encodes the desc direction of the first page.
     const result = await client.message.list({
       sessionID,
       ...(Number.isFinite(limit) ? { limit } : {}),
-      order: 'desc',
-      ...(typeof before === 'string' && before.length > 0 ? { cursor: before } : {}),
+      ...(typeof before === 'string' && before.length > 0 ? { cursor: before } : { order: 'desc' }),
     }, { signal });
 
     const items = Array.isArray(result?.data) ? result.data : null;
@@ -342,8 +250,8 @@ const createV2FetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
       throw error;
     }
 
-    const previous = result?.cursor?.previous;
-    const nextCursor = typeof previous === 'string' && previous.length > 0 ? previous : null;
+    const next = result?.cursor?.next;
+    const nextCursor = typeof next === 'string' && next.length > 0 ? next : null;
 
     return {
       records: items.slice().reverse(),
@@ -418,7 +326,14 @@ const createSdkFetchMessage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logge
     if (!data || typeof data !== 'object' || Array.isArray(data)) {
       throwUpstream(logger, '[session-turn-pages] session.message malformed payload');
     }
-    return projectSessionMessage(data);
+    const projected = projectSessionMessage(data);
+    // Control rows (idle / model-switched) are not chat messages.
+    if (!projected || !projected.info) {
+      const notFound = new Error('not_found');
+      notFound.code = 'not_found';
+      throw notFound;
+    }
+    return projected;
   };
 };
 

package/server/lib/session-turn-pages/routes.test.js

@@ -2,6 +2,10 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { registerSessionTurnPageRoutes } from './routes.js';
+import {
+  projectSessionMessage as projectSessionMessageRecord,
+  projectSessionMessageRecords,
+} from './session-message-projection.js';
 
 vi.mock('../opencode/v2-client.js', () => ({ makeOpenCodeV2Client: vi.fn() }));
 
@@ -33,6 +37,85 @@ const response = () => ({
 
 const ROUTE = '/api/openchamber/sessions/:sessionID/messages';
 
+describe('projectSessionMessageRecord (host SessionMessage → {info, parts})', () => {
+  it('drops idle control and projects two-turn wire without duplicate text', () => {
+    const records = projectSessionMessageRecords([
+      {
+        id: 'msg_u1',
+        type: 'user',
+        time: { created: 1 },
+        text: 'UI-E2E-FINAL-BUILD',
+        sessionID: 'ses_1',
+      },
+      {
+        id: 'msg_a1',
+        type: 'assistant',
+        time: { created: 2, completed: 3 },
+        sessionID: 'ses_1',
+        agent: 'build',
+        model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+        content: [
+          { type: 'reasoning', text: 'think' },
+          { type: 'text', text: 'FINAL_BUILD_OK' },
+        ],
+        finish: 'stop',
+        rawFinish: 'stop',
+      },
+      {
+        id: 'msg_u2',
+        type: 'user',
+        time: { created: 4 },
+        text: 'UI-E2E-FINAL-FOLLOWUP',
+        sessionID: 'ses_1',
+      },
+      {
+        id: 'msg_a2',
+        type: 'assistant',
+        time: { created: 5, completed: 6 },
+        sessionID: 'ses_1',
+        agent: 'build',
+        model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+        text: 'FINAL_FOLLOWUP_OK',
+        content: [
+          { type: 'reasoning', text: 'think2' },
+          { type: 'text', text: 'FINAL_FOLLOWUP_OK' },
+        ],
+        finish: 'stop',
+      },
+      {
+        id: 'msg_idle',
+        type: 'idle',
+        outcome: 'succeeded',
+        time: { created: 7 },
+      },
+    ]);
+
+    expect(records.map((row) => [row.info.role, row.info.id])).toEqual([
+      ['user', 'msg_u1'],
+      ['assistant', 'msg_a1'],
+      ['user', 'msg_u2'],
+      ['assistant', 'msg_a2'],
+    ]);
+    expect(projectSessionMessageRecord({
+      id: 'msg_idle2',
+      type: 'idle',
+      outcome: 'failed',
+      time: { created: 1 },
+    })).toBeNull();
+
+    const follow = records[3];
+    expect(follow.parts.filter((part) => part.type === 'text')).toHaveLength(1);
+    expect(follow.parts.find((part) => part.type === 'text').text).toBe('FINAL_FOLLOWUP_OK');
+    expect(follow.info.model).toEqual({
+      providerID: 'zai-coding-plan',
+      modelID: 'glm-5.3-flash',
+      variant: 'default',
+    });
+    expect(follow.info.type).toBeUndefined();
+    expect(follow.info.rawFinish).toBeUndefined();
+  });
+});
+
 describe('registerSessionTurnPageRoutes', () => {
   it('registers GET /api/openchamber/sessions/:sessionID/messages', () => {
     const { app, route } = registry();
@@ -737,6 +820,204 @@ describe('registerSessionTurnPageRoutes', () => {
     ]);
   });
 
+  it('default fetch continues desc pages with cursor.next only, never order + cursor', async () => {
+    const list = vi.fn()
+      .mockResolvedValueOnce({
+        data: [{ id: 'msg_a2', type: 'assistant', time: { created: 4, completed: 5 }, content: [{ type: 'text', text: 'later' }] }],
+        cursor: { previous: 'raw_prev', next: 'raw_next' },
+      })
+      .mockResolvedValueOnce({
+        data: [
+          { id: 'msg_a1', type: 'assistant', time: { created: 2, completed: 3 }, content: [{ type: 'text', text: 'ok' }] },
+          { id: 'msg_u1', type: 'user', time: { created: 1 }, text: 'hi' },
+        ],
+        cursor: { previous: 'raw_prev_2', next: null },
+      });
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_1' },
+      query: { turns: '1' },
+      headers: {},
+    }, res);
+
+    expect(list).toHaveBeenCalledTimes(2);
+    expect(list.mock.calls[0][0]).toEqual({ sessionID: 'ses_1', limit: 100, order: 'desc' });
+    expect(list.mock.calls[1][0]).toEqual({ sessionID: 'ses_1', limit: 100, cursor: 'raw_next' });
+    expect(res.statusCode).toBe(200);
+    expect(res.body.complete).toBe(true);
+    expect(res.body.records.map((record) => record.info.id)).toEqual(['msg_u1', 'msg_a1', 'msg_a2']);
+  });
+
+  it('drops v2 idle/control rows and does not double-expand text+content (FINAL-GATE cold reload)', async () => {
+    // Real wire shape from isolated backend hard-reload sessions:
+    // user + assistant(content) + idle outcome=succeeded, and assistants that
+    // occasionally carry both top-level text and content[].text.
+    const list = vi.fn(async () => ({
+      data: [
+        {
+          id: 'msg_idle_ok',
+          time: { created: 4 },
+          type: 'idle',
+          outcome: 'succeeded',
+        },
+        {
+          id: 'msg_a_follow',
+          time: { created: 3, completed: 4 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+          // Both carriers present — must project exactly one text part.
+          text: 'FINAL_FOLLOWUP_OK',
+          content: [
+            { type: 'reasoning', text: 'think' },
+            { type: 'text', text: 'FINAL_FOLLOWUP_OK' },
+          ],
+          finish: 'stop',
+          rawFinish: 'stop',
+          cost: 0,
+          tokens: { input: 1, output: 1, reasoning: 1, cache: { read: 0, write: 0 } },
+        },
+        {
+          id: 'msg_u_follow',
+          time: { created: 2 },
+          type: 'user',
+          text: 'UI-E2E-FINAL-FOLLOWUP',
+        },
+        {
+          id: 'msg_a1',
+          time: { created: 1, completed: 2 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+          content: [
+            { type: 'reasoning', text: 'first think' },
+            { type: 'text', text: 'FINAL_BUILD_OK' },
+          ],
+          finish: 'stop',
+        },
+        {
+          id: 'msg_u1',
+          time: { created: 0 },
+          type: 'user',
+          text: 'UI-E2E-FINAL-BUILD',
+        },
+      ],
+      cursor: { previous: null, next: null },
+    }));
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_final_build' },
+      query: { turns: '2' },
+      headers: {},
+    }, res);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body.records.map((row) => row.info.role)).toEqual([
+      'user',
+      'assistant',
+      'user',
+      'assistant',
+    ]);
+    expect(res.body.records.map((row) => row.info.id)).toEqual([
+      'msg_u1',
+      'msg_a1',
+      'msg_u_follow',
+      'msg_a_follow',
+    ]);
+    // No idle / control leakage into ChatMessage props.
+    expect(res.body.records.some((row) => row.info.role === 'idle' || row.info.type === 'idle')).toBe(false);
+    expect(JSON.stringify(res.body)).not.toContain('"type":"idle"');
+
+    const firstAssistant = res.body.records[1];
+    expect(firstAssistant.info.agent).toBe('build');
+    expect(firstAssistant.info.modelID).toBe('glm-5.3-flash');
+    expect(firstAssistant.info.model).toEqual({
+      providerID: 'zai-coding-plan',
+      modelID: 'glm-5.3-flash',
+      variant: 'default',
+    });
+    expect(firstAssistant.info.type).toBeUndefined();
+    expect(firstAssistant.info.rawFinish).toBeUndefined();
+    const firstTexts = firstAssistant.parts.filter((part) => part.type === 'text');
+    expect(firstTexts).toHaveLength(1);
+    expect(firstTexts[0].text).toBe('FINAL_BUILD_OK');
+
+    const followAssistant = res.body.records[3];
+    const followTexts = followAssistant.parts.filter((part) => part.type === 'text');
+    expect(followTexts).toHaveLength(1);
+    expect(followTexts[0].text).toBe('FINAL_FOLLOWUP_OK');
+    expect(followAssistant.parts.filter((part) => part.type === 'reasoning')).toHaveLength(1);
+  });
+
+  it('keeps provider.auth 401 assistant error and drops idle failed control', async () => {
+    const list = vi.fn(async () => ({
+      data: [
+        { id: 'msg_idle_fail', time: { created: 3 }, type: 'idle', outcome: 'failed' },
+        {
+          id: 'msg_a_401',
+          time: { created: 2, completed: 3 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'deepseek-flash', providerID: 'deepseek', variant: 'default' },
+          content: null,
+          finish: 'error',
+          error: {
+            type: 'provider.auth',
+            message: 'Authentication Fails, Your api key: **** is invalid',
+            status: 401,
+          },
+        },
+        { id: 'msg_u_401', time: { created: 1 }, type: 'user', text: 'UI-E2E-FINAL-DS' },
+      ],
+      cursor: { previous: null, next: null },
+    }));
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_ds' },
+      query: { turns: '1' },
+      headers: {},
+    }, res);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body.records).toHaveLength(2);
+    expect(res.body.records.map((row) => row.info.role)).toEqual(['user', 'assistant']);
+    const assistant = res.body.records[1];
+    expect(assistant.info.finish).toBe('error');
+    expect(assistant.info.error).toEqual({
+      type: 'provider.auth',
+      message: 'Authentication Fails, Your api key: **** is invalid',
+      status: 401,
+    });
+    expect(assistant.parts).toEqual([]);
+  });
+
   it('default fetch throws on message.list failure and maps to upstream', async () => {
     makeOpenCodeV2Client.mockReturnValue({
       message: { list: vi.fn(async () => { throw Object.assign(new Error('upstream'), { status: 500 }); }) },

package/server/lib/session-turn-pages/session-message-projection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type surface for session-message-projection.js (consumed by the VS Code
+ * turn-page bridge). Runtime implementation stays in the .js module.
+ */
+
+export type ProjectedSessionMessage = {
+  info: { id: string; role: string; [key: string]: unknown };
+  parts: unknown[];
+};
+
+export function projectSessionMessage(entry: unknown): ProjectedSessionMessage | null;
+
+export function projectSessionMessageRecords(records: unknown): ProjectedSessionMessage[];