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

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

@@ -0,0 +1,167 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { createSessionTitleRuntime } from './runtime.js';
+import { mergeMetadataPatch } from '../session-metadata/session-metadata-store.js';
+import { createTitleSessionAccess } from './session-access.js';
+import { configureServerOpenCodeFetchGate } from '../opencode/server-opencode-fetch.js';
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  configureServerOpenCodeFetchGate(null);
+});
+
+it.each([false, true])('runs a Host smart-title request and clears loading (model failure: %s)', async (fail) => {
+  vi.useFakeTimers();
+  const metadata = { openchamber: { titleRefresh: { lastAutoTitle: 'Original', requestedAt: 1000 } } };
+  const session = { id: 'ses_title', title: 'Original', directory: '/repo', metadata };
+  const updates = [];
+  const sessionAccess = {
+    get: vi.fn(async () => structuredClone(session)),
+    update: vi.fn(async (_id, _directory, patch) => {
+      if (patch.title) session.title = patch.title;
+      if (patch.metadata) session.metadata = mergeMetadataPatch(session.metadata, patch.metadata);
+      updates.push(structuredClone(session));
+    }),
+    messages: vi.fn(async () => [
+      { info: { id: 'u1', role: 'user' }, parts: [{ type: 'text', text: 'Implement a title refresh' }] },
+      { info: { id: 'a1', role: 'assistant' }, parts: [{ type: 'text', text: 'Done' }] },
+    ]),
+  };
+  const generate = vi.fn(async () => {
+    expect(session.metadata.openchamber.titleRefresh.isGenerating).toBe(true);
+    if (fail) throw new Error('title model unavailable');
+    return { text: 'Title refresh', providerID: 'test', modelID: 'test' };
+  });
+  const runtime = createSessionTitleRuntime({
+    sessionAccess,
+    buildOpenCodeUrl: (path) => `http://opencode${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    getSmallModelService: async () => ({ generateSmallModelText: generate }),
+    now: () => 1000,
+  });
+  try {
+    runtime.processPayload({ type: 'openchamber:session-metadata', properties: {
+      sessionID: session.id, directory: '/repo', metadata,
+    } });
+    await vi.runAllTimersAsync();
+    expect(generate).toHaveBeenCalledTimes(1);
+    expect(session.title).toBe(fail ? 'Original' : 'Title refresh');
+    if (fail) expect(session.metadata.openchamber.titleRefresh.lastError).toBe('title model unavailable');
+    expect(session.metadata.openchamber.titleRefresh.isGenerating).not.toBe(true);
+    expect(session.metadata.openchamber.titleRefresh.requestedAt).toBeUndefined();
+    expect(updates.some((row) => row.metadata.openchamber.titleRefresh.isGenerating)).toBe(true);
+  } finally {
+    runtime.stop();
+  }
+});
+
+it('uses the real v2 client and publishes the generated title without another session click', async () => {
+  vi.useFakeTimers();
+  configureServerOpenCodeFetchGate(null, { allowMissingContract: true });
+  let metadata = { openchamber: { titleRefresh: { lastAutoTitle: 'Original', requestedAt: 1000 } } };
+  const session = { id: 'ses_title', title: 'Original', location: { directory: '/repo' }, time: { created: 1, updated: 2 } };
+  const requests = [];
+  vi.stubGlobal('fetch', vi.fn(async (input, init) => {
+    const request = input instanceof Request ? input : new Request(input, init);
+    const url = new URL(request.url);
+    requests.push(`${request.method} ${url.pathname}`);
+    if (url.pathname.endsWith('/message')) {
+      expect(url.searchParams.get('order')).toBe('desc');
+      return Response.json({ data: [
+        { id: 'a1', type: 'assistant', content: [{ type: 'text', text: 'Done' }] },
+        { id: 'u1', type: 'user', text: 'Implement title refresh' },
+      ] });
+    }
+    if (request.method === 'PATCH') {
+      const body = await request.json();
+      expect(Object.keys(body)).toEqual(['title']);
+      session.title = body.title;
+      return new Response(null, { status: 204 });
+    }
+    return Response.json({ data: session });
+  }));
+  const events = [];
+  const access = createTitleSessionAccess({
+    buildOpenCodeUrl: (path) => `http://opencode${path}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    readSessionMetadata: async () => metadata,
+    persistSessionMetadata: async (_id, patch) => {
+      metadata = mergeMetadataPatch(metadata, patch);
+      events.push({ type: 'metadata', metadata: structuredClone(metadata) });
+    },
+    publishSession: (row) => events.push({ type: 'session', row }),
+  });
+  const runtime = createSessionTitleRuntime({
+    sessionAccess: access,
+    getSmallModelService: async () => ({ generateSmallModelText: async () => ({ text: 'Title refresh', providerID: 'test', modelID: 'test' }) }),
+    now: () => 1000,
+  });
+  try {
+    runtime.processPayload({ type: 'openchamber:session-metadata', properties: {
+      sessionID: session.id, metadata, directory: '/repo',
+    } });
+    await vi.runAllTimersAsync();
+    expect(events.some((event) => event.metadata?.openchamber?.titleRefresh?.isGenerating === true)).toBe(true);
+    expect(events.at(-1)).toMatchObject({ type: 'session', row: { title: 'Title refresh', directory: '/repo' } });
+    expect(metadata.openchamber.titleRefresh.isGenerating).toBeUndefined();
+    expect(requests).toContain('PATCH /api/session/ses_title');
+  } finally {
+    runtime.stop();
+  }
+});
+
+it('starts the first title from admitted user text while the assistant is still running', async () => {
+  vi.useFakeTimers();
+  const session = {
+    id: 'ses_first', title: '', time: { created: 1, updated: 1 },
+    metadata: {},
+  };
+  let finishTitle;
+  const generation = new Promise((resolve) => { finishTitle = resolve; });
+  const generate = vi.fn(() => generation);
+  const access = {
+    get: vi.fn(async () => structuredClone(session)),
+    update: vi.fn(async (_id, _directory, patch) => {
+      if (patch.metadata) session.metadata = mergeMetadataPatch(session.metadata, patch.metadata);
+      if (patch.title) session.title = patch.title;
+    }),
+    messages: vi.fn(async () => []),
+  };
+  const runtime = createSessionTitleRuntime({
+    sessionAccess: access,
+    getSmallModelService: async () => ({ generateSmallModelText: generate }),
+    isTitleRefreshEnabled: () => true,
+    now: () => 1000,
+  });
+  const emit = (type, data) => runtime.processPayload({ type, data, created: 1000, location: { directory: '/repo' } });
+  try {
+    emit('session.created', { sessionID: session.id, location: { directory: '/repo' } });
+    emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_synthetic', item: {
+      type: 'synthetic', delivery: 'steer', payload: { text: 'Internal instructions' },
+    } });
+    await vi.runAllTimersAsync();
+    expect(generate).not.toHaveBeenCalled();
+    emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_first', item: {
+      type: 'user', delivery: 'steer', payload: { text: 'Implement a session title generator' },
+    } });
+    emit('session.execution.started', { sessionID: session.id });
+    emit('session.status', { sessionID: session.id, status: { type: 'busy' } });
+    await vi.runAllTimersAsync();
+    expect(generate).toHaveBeenCalledTimes(1);
+    expect(generate.mock.calls[0][0].prompt).toContain('Implement a session title generator');
+    expect(session.metadata.openchamber?.titleRefresh?.isGenerating).toBe(true);
+    expect(access.messages).not.toHaveBeenCalled();
+    finishTitle({ text: 'Session titles', providerID: 'test', modelID: 'test' });
+    await vi.runAllTimersAsync();
+    expect(session.title).toBe('Session titles');
+    expect(session.metadata.openchamber.titleRefresh.isGenerating).toBeUndefined();
+    emit('session.execution.succeeded', { sessionID: session.id });
+    emit('session.inbox.enqueued', { sessionID: session.id, inboxID: 'msg_second', item: {
+      type: 'user', delivery: 'steer', payload: { text: 'Follow up on the implementation' },
+    } });
+    await vi.runAllTimersAsync();
+    expect(generate).toHaveBeenCalledTimes(1);
+  } finally {
+    runtime.stop();
+  }
+});

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
 
@@ -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