@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

package/server/lib/session-title/runtime.js

@@ -131,14 +131,18 @@ const buildTitleSystemPrompt = () => [
 ].join('\n');
 
 const extractSessionStatus = (payload) => {
-  if (!payload || payload.type !== 'session.status') return null;
-  const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
+  if (!payload) return null;
+  const executionType = payload.type === 'session.execution.started' ? 'busy'
+    : payload.type === 'session.execution.succeeded' || payload.type === 'session.execution.failed' ? 'idle'
+      : null;
+  if (payload.type !== 'session.status' && !executionType) return null;
+  const properties = payload.properties ?? payload.data ?? {};
   const status = properties.status && typeof properties.status === 'object' ? properties.status : {};
   const info = properties.info && typeof properties.info === 'object' ? properties.info : {};
   const sessionId = typeof properties.sessionID === 'string' ? properties.sessionID.trim() : '';
-  const type = typeof status.type === 'string'
+  const type = executionType ?? (typeof status.type === 'string'
     ? status.type.trim()
-    : (typeof info.type === 'string' ? info.type.trim() : '');
+    : (typeof info.type === 'string' ? info.type.trim() : ''));
   if (!sessionId || !type) return null;
   const directory = typeof properties.directory === 'string' && properties.directory
     ? properties.directory
@@ -159,9 +163,11 @@ export const isSystemOwnedSession = (sessionOrInfo) => {
 };
 
 const extractTitleRefreshRequest = (payload) => {
-  if (!payload || payload.type !== 'session.updated') return null;
+  if (!payload || (payload.type !== 'session.updated' && payload.type !== 'openchamber:session-metadata')) return null;
   const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
-  const info = properties.info && typeof properties.info === 'object' ? properties.info : {};
+  const info = payload.type === 'openchamber:session-metadata'
+    ? { id: properties.sessionID, metadata: properties.metadata }
+    : (properties.info && typeof properties.info === 'object' ? properties.info : {});
   if (isSystemOwnedSession(info)) return null;
   const sessionId = typeof info.id === 'string' ? info.id.trim() : '';
   const titleRefresh = info.metadata?.openchamber?.titleRefresh;
@@ -176,20 +182,35 @@ const extractTitleRefreshRequest = (payload) => {
 
 const extractCreatedSession = (payload) => {
   if (!payload || payload.type !== 'session.created') return null;
-  const properties = payload.properties && typeof payload.properties === 'object' ? payload.properties : {};
-  const info = properties.info && typeof properties.info === 'object' ? properties.info : {};
+  const properties = payload.properties ?? payload.data ?? {};
+  const info = properties.info ?? { ...properties, id: properties.sessionID };
   const sessionId = typeof info.id === 'string' ? info.id.trim() : '';
   if (!sessionId || (typeof info.parentID === 'string' && info.parentID)) return null;
   if (isSystemOwnedSession(info)) return null;
   const directory = typeof properties.directory === 'string' && properties.directory
     ? properties.directory
-    : (typeof info.directory === 'string' ? info.directory : '');
-  const createdAt = typeof info.time?.created === 'number' ? info.time.created : Date.now();
+    : (typeof info.location?.directory === 'string' ? info.location.directory : (typeof info.directory === 'string' ? info.directory : ''));
+  const createdAt = typeof info.time?.created === 'number' ? info.time.created : (payload.created ?? Date.now());
   const title = typeof info.title === 'string' ? info.title : '';
   return { sessionId, directory, createdAt, title };
 };
 
 const extractUserMessage = (payload) => {
+  if (payload?.type === 'session.inbox.enqueued') {
+    const properties = payload.properties ?? payload.data ?? {};
+    const item = properties.item;
+    if (typeof properties.sessionID !== 'string' || item?.type !== 'user') return null;
+    const text = typeof item.payload?.text === 'string' ? item.payload.text.slice(0, TRANSCRIPT_USER_CHAR_LIMIT) : '';
+    return {
+      sessionId: properties.sessionID,
+      createdAt: payload.created ?? 0,
+      directory: payload.location?.directory ?? '',
+      initialRecord: text.trim() ? {
+        info: { id: properties.inboxID, role: 'user' },
+        parts: [{ type: 'text', text }],
+      } : null,
+    };
+  }
   if (!payload || payload.type !== 'message.updated') return null;
   const info = payload.properties?.info;
   if (!info || typeof info !== 'object' || info.role !== 'user') return null;
@@ -351,6 +372,9 @@ export const buildLatestTitleTranscript = (
 export const createSessionTitleRuntime = ({
   buildOpenCodeUrl,
   getOpenCodeAuthHeaders,
+  /** Ticket 11: Host write admission shared with proxy (optional). */
+  serverOpenCodeFetch = null,
+  sessionAccess = null,
   getSmallModelService,
   quietMs = TITLE_QUIET_MS,
   throttleMs = TITLE_THROTTLE_MS,
@@ -362,6 +386,7 @@ export const createSessionTitleRuntime = ({
   const forcedRefreshes = new Set();
   const initialRefreshes = new Set();
   const newSessions = new Set();
+  const initialUserMessages = new Map();
   const forkFirstSendPending = new Map();
   const forkFirstRefreshes = new Set();
   /** In-memory throttle timestamps (metadata also persists across restarts). */
@@ -377,6 +402,20 @@ export const createSessionTitleRuntime = ({
   };
 
   const openCodeFetch = async (pathname, { directory, method = 'GET', body } = {}) => {
+    if (sessionAccess) {
+      const sessionId = decodeURIComponent(pathname.slice('/session/'.length));
+      return method === 'PATCH'
+        ? sessionAccess.update(sessionId, directory, body)
+        : sessionAccess.get(sessionId, directory);
+    }
+    if (typeof serverOpenCodeFetch === 'function') {
+      return serverOpenCodeFetch(pathname, {
+        directory,
+        method,
+        body,
+        timeoutMs: FETCH_TIMEOUT_MS,
+      });
+    }
     const base = buildOpenCodeUrl(pathname, '');
     const url = directory ? `${base}?directory=${encodeURIComponent(directory)}` : base;
     const response = await fetch(url, {
@@ -396,6 +435,7 @@ export const createSessionTitleRuntime = ({
   };
 
   const fetchRecentMessages = async (sessionId, directory) => {
+    if (sessionAccess) return sessionAccess.messages(sessionId, directory, TRANSCRIPT_MESSAGE_LIMIT);
     const base = buildOpenCodeUrl(`/session/${encodeURIComponent(sessionId)}/message`, '');
     const params = new URLSearchParams({ limit: String(TRANSCRIPT_MESSAGE_LIMIT) });
     if (directory) params.set('directory', directory);
@@ -421,20 +461,13 @@ export const createSessionTitleRuntime = ({
 
     const meta = readTitleRefreshMeta(session);
     if (meta.titleRefresh.isGenerating !== true) return;
-    const {
-      isGenerating: _isGenerating,
-      requestedAt: _requestedAt,
-      ...titleRefresh
-    } = meta.titleRefresh;
     await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, {
       directory,
       method: 'PATCH',
       body: {
         metadata: {
-          ...meta.metadata,
           openchamber: {
-            ...meta.openchamber,
-            titleRefresh,
+            titleRefresh: { isGenerating: null, requestedAt: null },
           },
         },
       },
@@ -446,17 +479,13 @@ export const createSessionTitleRuntime = ({
       .catch(() => null);
     if (!session || typeof session !== 'object') return;
 
-    const meta = readTitleRefreshMeta(session);
     await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, {
       directory,
       method: 'PATCH',
       body: {
         metadata: {
-          ...meta.metadata,
           openchamber: {
-            ...meta.openchamber,
             titleRefresh: {
-              ...meta.titleRefresh,
               lastError: error instanceof Error ? error.message : String(error),
               failedAt: now(),
             },
@@ -505,11 +534,8 @@ export const createSessionTitleRuntime = ({
       method: 'PATCH',
       body: {
         metadata: {
-          ...meta.metadata,
           openchamber: {
-            ...meta.openchamber,
             titleRefresh: {
-              ...meta.titleRefresh,
               activityUpdatedAt,
             },
           },
@@ -524,6 +550,8 @@ export const createSessionTitleRuntime = ({
   const generateTitle = async (sessionId, directory) => {
     const forceRefresh = forcedRefreshes.delete(sessionId);
     const initialRefresh = initialRefreshes.delete(sessionId);
+    const initialUserMessage = initialUserMessages.get(sessionId);
+    initialUserMessages.delete(sessionId);
     const forkFirstRefresh = forkFirstRefreshes.delete(sessionId);
     if (!forceRefresh && !isTitleRefreshEnabled()) return;
 
@@ -558,15 +586,14 @@ export const createSessionTitleRuntime = ({
       return;
     }
 
-    const messages = await fetchRecentMessages(sessionId, directory);
+    const messages = initialUserMessage ? [initialUserMessage] : await fetchRecentMessages(sessionId, directory);
     if (!messages || messages.length === 0) return;
 
     const { transcript, lastAssistantId, realUserCount, languageSample } = buildLatestTitleTranscript(messages);
     if (!transcript) return;
 
-    // Let OpenCode's first-message title land first. We only refresh once the
-    // conversation has moved on (2+ real user turns), unless the title is
-    // still the default placeholder.
+    // Initial titles use the admitted first user message immediately; ordinary
+    // later refreshes still require a moved-on conversation or placeholder.
     if (!forceRefresh && !initialRefresh && !forkFirstRefresh && realUserCount < 2 && !isDefaultSessionTitle(currentTitle)) {
       return;
     }
@@ -597,14 +624,11 @@ export const createSessionTitleRuntime = ({
       method: 'PATCH',
       body: {
         metadata: {
-          ...meta.metadata,
           openchamber: {
-            ...meta.openchamber,
             titleRefresh: {
-              ...meta.titleRefresh,
               isGenerating: true,
-              lastError: undefined,
-              failedAt: undefined,
+              lastError: null,
+              failedAt: null,
             },
           },
         },
@@ -677,9 +701,6 @@ export const createSessionTitleRuntime = ({
     const generatedAt = now();
     lastGeneratedAtBySession.set(sessionId, generatedAt);
 
-    const currentMetadata = freshMeta.metadata;
-    const currentNamespace = freshMeta.openchamber;
-
     console.log(`[session-title] refreshed ${sessionId} → "${nextTitle}" via ${generated.providerID}/${generated.modelID}`);
     await openCodeFetch(`/session/${encodeURIComponent(sessionId)}`, {
       directory,
@@ -687,11 +708,8 @@ export const createSessionTitleRuntime = ({
       body: {
         title: nextTitle,
         metadata: {
-          ...currentMetadata,
           openchamber: {
-            ...currentNamespace,
             titleRefresh: {
-              ...freshMeta.titleRefresh,
               lastAutoTitle: nextTitle,
               forMessageID: lastAssistantId || latestAssistantId || '',
               generatedAt,
@@ -723,6 +741,7 @@ export const createSessionTitleRuntime = ({
 
   const processPayload = (payload, directoryHint = '') => {
     if (stopped) return;
+    directoryHint = directoryHint || payload?.location?.directory || '';
     const createdSession = extractCreatedSession(payload);
     if (createdSession) {
       if (isForkedSessionTitle(createdSession.title)) {
@@ -758,13 +777,18 @@ export const createSessionTitleRuntime = ({
           initialRefreshes.add(status.sessionId);
           armTimer(status.sessionId, status.directory || directoryHint, 0);
         }
-      } else {
+      } else if (!initialRefreshes.has(status.sessionId)) {
         clearTimer(status.sessionId);
       }
       return;
     }
     const userMessage = extractUserMessage(payload);
     if (userMessage) {
+      if (userMessage.initialRecord && newSessions.delete(userMessage.sessionId)) {
+        initialRefreshes.add(userMessage.sessionId);
+        initialUserMessages.set(userMessage.sessionId, userMessage.initialRecord);
+        armTimer(userMessage.sessionId, userMessage.directory || directoryHint, 0);
+      }
       const pendingFork = forkFirstSendPending.get(userMessage.sessionId);
       if (pendingFork && userMessage.createdAt > pendingFork.createdAt) {
         pendingFork.hasNewUserMessage = true;
@@ -780,7 +804,7 @@ export const createSessionTitleRuntime = ({
       // session settles. Only a message created after the timer was armed
       // means the user actually moved on.
       const armed = timers.get(userMessage.sessionId);
-      if (armed && userMessage.createdAt >= armed.armedAt) {
+      if (armed && !initialRefreshes.has(userMessage.sessionId) && userMessage.createdAt >= armed.armedAt) {
         clearTimer(userMessage.sessionId);
       }
     }
@@ -792,6 +816,7 @@ export const createSessionTitleRuntime = ({
       clearTimeout(timer);
     }
     timers.clear();
+    initialUserMessages.clear();
   };
 
   return { processPayload, stop, armTimer };

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

@@ -0,0 +1,46 @@
+import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
+import { projectSessionWithHostMetadata } from '../session-metadata/session-projection.js';
+import { projectSessionMessageRecords } from '../session-turn-pages/session-message-projection.js';
+
+/** Title reads use OpenCode; title-refresh metadata and its notifications belong to the Host. */
+export function createTitleSessionAccess({
+  buildOpenCodeUrl,
+  getOpenCodeAuthHeaders,
+  readSessionMetadata,
+  persistSessionMetadata,
+  publishSession,
+}) {
+  const client = () => makeOpenCodeV2Client({
+    baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
+    authHeaders: getOpenCodeAuthHeaders(),
+  });
+  const options = () => ({ signal: AbortSignal.timeout(30_000) });
+  const get = async (sessionID) => {
+    const session = await client().session.get({ sessionID }, options());
+    return projectSessionWithHostMetadata(session, await readSessionMetadata(sessionID));
+  };
+  return {
+    get,
+    async messages(sessionID, _directory, limit) {
+      const page = await client().message.list({ sessionID, limit, order: 'desc' }, options());
+      if (!Array.isArray(page?.data)) throw new Error('Session title: invalid message page');
+      return projectSessionMessageRecords([...page.data].reverse());
+    },
+    async update(sessionID, directory, patch) {
+      if (typeof patch.title === 'string') {
+        await client().session.update({ sessionID, title: patch.title }, options());
+      }
+      // Never write the complete metadata snapshot back: goal/archive/ownership
+      // may have changed while the title model was running.
+      const refresh = patch.metadata?.openchamber?.titleRefresh;
+      if (refresh) {
+        await persistSessionMetadata(sessionID, { openchamber: { titleRefresh: refresh } });
+      }
+      if (typeof patch.title === 'string' || (refresh && Object.hasOwn(refresh, 'isGenerating'))) {
+        const session = await get(sessionID);
+        await publishSession(session, directory);
+        return session;
+      }
+    },
+  };
+}

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
 
@@ -34,7 +34,7 @@ Official OpenCode pagination is message-count based and uses **opaque** cursors
 | `scanLimit` | **omitted** | `10..200` when present | Optional override only. Host→OpenCode local page size; when omitted it resolves to `_inner_scanLimit`. Clients should omit this. |
 | `before` | omitted | opaque string ≤ 8192 chars | Resume older history: host cursor (`oc1.…`) or raw OpenCode SDK cursor on first page |
 | `directory` | omitted | path string | Forwarded to directory-scoped OpenCode client |
-| `includeReasoning` | omitted (include) | strict `'false'` only disables | OpenChamber projection control. When `'false'`, drop `type=reasoning` parts from turn-page / reconcile / exact responses after other projections. Missing or any other value keeps existing behavior (slim reasoning identity on turn pages; full parts on reconcile/exact). **Never forwarded to OpenCode.** Same contract on transcript-cache reads, official `session.messages` list proxy, and event SSE/WS send boundaries — see `event-stream/reasoning-projection.js`. |
+| `includeReasoning` | omitted (include) | strict `'false'` only disables | OpenChamber projection control. When `'false'`, drop `type=reasoning` parts from turn-page / reconcile / exact responses. Host order is **normalize native SessionMessageInfo → slim/L1 bounds → reasoning strip** so `content`/`text` carriers cannot rebuild filtered parts or leak through `info` expansion. Missing or any other value keeps existing behavior (slim reasoning identity on turn pages; full parts on reconcile/exact). **Never forwarded to OpenCode.** Same contract on transcript-cache reads, official `session.messages` list proxy, and event SSE/WS send boundaries — see `event-stream/reasoning-projection.js`. |
 
 Invalid `turns`, explicit invalid `scanLimit`, or `before` (malformed/stale host token, oversize) → HTTP 400.
 
@@ -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.
@@ -82,7 +82,7 @@ Every turn-page response summarizes `tool`, `reasoning`, and `file` parts plus m
 |---|---|---|
 | **L1** | Turn pages, reconcile response pages, message/session SSE fan-out, exact `GET /api/session/:sessionID/message/:messageID` | Any `info.summary.diffs` **array** is projected to a **slim file list** `[{ file, status?, additions, deletions }]` plus additive markers `summary.diffCount: number` and `summary.hasDiffs: boolean`. Patch/before/after/from/to and other heavy bodies are stripped. Other lightweight summary fields are preserved. `diffCount` equals the slim array length; `hasDiffs === diffCount > 0`. Consumers may use either the slim array or the markers. |
 | **L2** | `GET /api/openchamber/sessions/:sessionID/changes?messageID=` (no `file`) | Host reads official `session.message` locally, returns only `{ files: [{ file, status?, additions, deletions }] }`. Never returns patch/before/after/from/to or the full message envelope. |
-| **L3** | Same route with `file=` | Host calls official `session.diff({ sessionID, messageID, directory })`, returns `{ diff: SnapshotFileDiff }` for the exact `file` string match (includes that file's patch). No match → HTTP 404 `{ error: 'change file not found', code: 'change_not_found' }`. Older hosts may ignore `file=` and answer 200 `{ files }` (L2 only). Current clients treat a 200 without `{ diff }` as missing L3 and fall back to official `session.diff`. |
+| **L3** | Same route with `file=` | Host currently still reads `info.summary.diffs` from the exact message payload when present. **v2 `SessionMessageInfo` has no `summary.diffs`**, so L3 fails closed with upstream 502 until a parent follow-up lands an authoritative per-message diff source. Do **not** substitute working-tree / `vcs.diff` here. When diffs are available, returns `{ diff: SnapshotFileDiff }` for the exact `file` string match. No match → HTTP 404 `{ error: 'change file not found', code: 'change_not_found' }`. Older hosts may ignore `file=` and answer 200 `{ files }` (L2 only). |
 
 Exact message GET keeps the official `{ info, parts }` response shape and only applies L1 summary projection so materialize/recovery never relays raw multi-megabyte patch bodies through the generic proxy. Abort/45s timeout semantics match the turn-page routes. Global `/api` auth still applies.
 
@@ -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
@@ -263,7 +264,7 @@ When the per-page budget fills before the gap is complete, the host returns `con
 - `service.js` — `isUserAuthoredTurnBoundary`, `selectTurnRecords`, `encodeHostCursor`, `decodeHostCursor`, `projectMessageDiffSummaries` (L1), `projectSlimParts`, `createSessionTurnPageService({ fetchPage, maxScanPages?, maxScanMessages? })`
 - `reconcile.service.js` — `encodeReconcileContinuation`, `decodeReconcileContinuation`, `createSessionReconcileService({ fetchPage, runtimeKey?, page/total budgets?, continuationSecret?, clock?, continuationTtlMs? })`
 - `changes.service.js` — `createSessionChangesService({ fetchMessage, fetchDiff })` for L2/L3; injectable for unit tests
-- `routes.js` — Express registration for turn-page, reconcile, Changes, and exact message GET; optional injected `sessionTurnPageService` / `sessionReconcileService` / `sessionChangesService` / `fetchExactMessage` for tests; default wires SDK `session.messages` / `session.message` / `session.diff` via `buildOpenCodeUrl` + `getOpenCodeAuthHeaders`
+- `routes.js` — Express registration for turn-page, reconcile, Changes, and exact message GET; optional injected `sessionTurnPageService` / `sessionReconcileService` / `sessionChangesService` / `fetchExactMessage` for tests; default wires `@opencode/client` `OpenCode.make` (`message.list` / `session.message`) via `buildOpenCodeUrl` + `getOpenCodeAuthHeaders`. Exact/not-found classification honors real client `_tag` (`MessageNotFoundError` / `SessionNotFoundError`) and preserves abort → HTTP 499 (never folds abort into 502).
 - `service.test.js` / `routes.test.js` / `reconcile.service.test.js` / `reconcile.routes.test.js` / `changes.service.test.js` — unit contracts
 
 ## Registration

package/server/lib/session-turn-pages/reconcile.service.js

@@ -47,7 +47,7 @@ const PROCESS_CONTINUATION_SECRET = randomBytes(32);
 const fail = (error) => ({ ok: false, error });
 
 const recordId = (record) => {
-  const id = record?.info?.id;
+  const id = record?.info?.id ?? record?.id;
   return typeof id === 'string' && id.length > 0 ? id : null;
 };
 

package/server/lib/session-turn-pages/reconcile.service.test.js

@@ -686,4 +686,20 @@ describe('createSessionReconcileService', () => {
     expect(result.ok).toBe(true);
     expect(result.resetRequired).toBe(true);
   });
+
+  it('locates a SessionMessageInfo anchor by top-level id', async () => {
+    const fetchPage = vi.fn(async () => pageResult([
+      { id: 'msg_u1', type: 'user', time: { created: 1 }, text: 'hi' },
+      { id: 'msg_a1', type: 'assistant', time: { created: 2, completed: 3 }, content: [{ type: 'text', text: 'ok' }] },
+    ], null));
+    const service = createSessionReconcileService(serviceOptions(fetchPage));
+    const result = await service.reconcile({
+      sessionID: 'ses_1',
+      directory: '/repo',
+      anchor: 'msg_u1',
+    });
+    expect(result.ok).toBe(true);
+    expect(result.anchorFound).toBe(true);
+    expect(result.records.map((entry) => entry.id)).toEqual(['msg_u1', 'msg_a1']);
+  });
 });