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

package/server/lib/session-metadata/system-session.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import {
+  LLM_SESSION_PURPOSE,
+  buildAssistantSessionMetadata,
+  buildLlmSessionMetadata,
+  buildScheduledTaskMetadata,
+} from './system-session.js';
+
+describe('system session metadata builders', () => {
+  it('builds scheduled-task isolation from a non-empty taskID', () => {
+    expect(buildScheduledTaskMetadata({
+      projectID: 'project-1',
+      taskID: 'task-1',
+      runID: 'run-1',
+      name: 'Morning Sync',
+    })).toEqual({
+      openchamber: {
+        scheduledTask: {
+          taskID: 'task-1',
+          projectID: 'project-1',
+          runID: 'run-1',
+          name: 'Morning Sync',
+        },
+      },
+    });
+  });
+
+  it('refuses scheduled-task metadata without taskID', () => {
+    expect(() => buildScheduledTaskMetadata({ projectID: 'project-1' })).toThrow(/taskID/);
+  });
+
+  it('builds llm isolation with the chat-completions purpose', () => {
+    expect(buildLlmSessionMetadata()).toEqual({
+      openchamber: { llm: { purpose: LLM_SESSION_PURPOSE } },
+    });
+    expect(buildLlmSessionMetadata('  ')).toEqual({
+      openchamber: { llm: { purpose: LLM_SESSION_PURPOSE } },
+    });
+  });
+
+  it('builds assistant isolation from a non-empty assistantID', () => {
+    expect(buildAssistantSessionMetadata({
+      assistantID: 'assistant_1',
+      name: 'Ops',
+    })).toEqual({
+      openchamber: {
+        assistant: { assistantID: 'assistant_1', name: 'Ops' },
+      },
+    });
+  });
+
+  it('refuses assistant metadata without assistantID', () => {
+    expect(() => buildAssistantSessionMetadata({ name: 'Ops' })).toThrow(/assistantID/);
+  });
+});

package/server/lib/session-title/DOCUMENTATION.md

@@ -5,20 +5,53 @@ conversation's **main subject** (overall feature / goal) with the small model
 (`lib/small-model`), then PATCHes `title` plus `metadata.openchamber.titleRefresh`.
 
 OpenCode only auto-titles once from the first user message
-(`SessionPrompt.ensureTitle`). This module auto-refreshes sparsely (first idle
-of a new session, first newly-sent reply on a fork) and on explicit smart-title
+(`SessionPrompt.ensureTitle`). This module auto-refreshes sparsely (first user
+admission of a new session, first newly-sent reply on a fork) and on explicit smart-title
 requests, naming the durable work being done — not the last wrap-up utterance
 like "commit and push". Background auto refreshes still respect a 5-minute
 throttle (`TITLE_THROTTLE_MS`) when a refresh is armed.
 
 ## Flow
 
+### OpenCode 2 smart-title boundary
+
+Manual requests arrive as Host `openchamber:session-metadata` writes. The
+metadata route's committed-write callback explicitly notifies the title runtime;
+it must not rely on OpenCode echoing Host metadata as `session.updated`.
+`session-access.js` owns the production boundary: official client session reads
+and title updates, a bounded `message.list({ order: 'desc' })` page projected into
+chronological transcript records, and Host metadata reads/merge patches.
+Only changed `titleRefresh` fields are persisted. Transient fields are removed
+with RFC 7386 `null`, so `isGenerating` and `requestedAt` cannot survive a clear.
+Unrelated goal, archive, and ownership metadata is never replaced by a title read.
+
+After a successful title write or generation-state change, an authoritative full session row is published
+as `session.updated` and applied to the session index. Connected clients receive
+both loading metadata and the new title without reselecting the session. Neither
+event represents an execution-status transition: the original session's busy /
+retry status and subsequent execution events remain independently authoritative.
+Publishing the loading row also covers first-send admission arriving before the
+renderer inserts the new session: a metadata-only event would otherwise be ignored
+for that still-unknown row.
+This Host path serves web, Electron, and connected hosted/native mobile clients;
+extension-only VS Code retains the limitation below.
+
 1. `createSessionTitleRuntime` is a consumer of the server's global SSE
    fan-out (`index.js` → `globalMessageStreamHub.subscribeEvent`). Purely event-driven — dormant sessions never
    generate anything.
-  2. Auto title refresh is intentionally sparse (title stability first). A newly
-     observed root `session.created` generates its first title immediately on the
-     first `session.status: idle`. A fork title (`(fork #n)`) waits for its first
+   2. Auto title refresh is intentionally sparse (title stability first). A newly
+      observed root `session.created` generates its first title immediately on
+      the first native `session.inbox.enqueued` user item. Native `data` envelopes
+      are accepted alongside legacy `properties`. The admitted text is bounded
+      to the user-message limit and retained only until the generation starts;
+      it avoids a race with the not-yet-materialized message projection. Synthetic,
+      compaction, and move items cannot start this title. Busy/execution-start
+      events do not cancel this first-title timer: title generation and the main
+      assistant reply run concurrently. Generation publishes `isGenerating` via
+      the existing Host metadata path, then the final title through `session.updated`.
+      Later user admissions/idle events do not regenerate the initial title.
+      The legacy first-idle edge remains a fallback when no admission was observed.
+      A fork title (`(fork #n)`) waits for its first
      newly-created user message; the matching assistant completion triggers an
      immediate title refresh that bypasses inherited title metadata and throttle.
      If the fork's `session.created` was lost (SSE reconnect gap, server or
@@ -27,8 +60,8 @@ throttle (`TITLE_THROTTLE_MS`) when a refresh is armed.
      title + message created after the fork + activity timestamp not yet past
      the fork time), so the first-reply refresh still fires.
      Ordinary later idle transitions do **not** arm another refresh. Any
-     `busy`/`retry` status or a fresh user `message.updated` still clears an
-     already-armed timer (so initial/fork timers cancel if the user keeps going).
+      `busy`/`retry` status or a fresh user `message.updated` still clears an
+      ordinary already-armed timer; an admitted first-title timer is exempt.
      A sidebar smart-title request sets `titleRefresh.requestedAt`; its
      `session.updated` event arms the same flow immediately (forced / manual
      refresh is unaffected by the background gate).

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

@@ -122,8 +122,8 @@ const buildTitleSystemPrompt = () => [
   'Name the main subject of the work.',
   'Keep that subject across follow-ups, polish, commit, push, tidy, and review.',
   'Switch only when the user clearly starts a different topic.',
-  'One line, ≤50 characters, no explanation.',
-  'Prefer ≤6 words or ≤6 CJK characters. No modifiers. No verbs.',
+  'One line, no explanation.',
+  'Hard limit: never exceed 6 CJK characters (or 6 words for English). No modifiers. No verbs.',
   'Use the language of the user messages.',
   'Keep technical terms, numbers, filenames, and HTTP codes exact.',
   'Never include tool names, summarizing, or generating.',
@@ -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;
+      }
+    },
+  };
+}