@openchambery/web 2.0.0-beta.9 → 2.0.1

package/server/lib/scheduled-tasks/runtime.test.js

@@ -1108,6 +1108,78 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     expect(client.prompt).not.toHaveBeenCalled();
   });
 
+  it.each([
+    ['succeeded', 'success', null],
+    ['failed', 'error', 'session execution failed'],
+    ['interrupted', 'error', 'session execution interrupted'],
+  ])('settles native idle outcome %s instead of timing out', async (outcome, status, error) => {
+    vi.useFakeTimers();
+    try {
+      const history = createHistoryStore();
+      const client = createSuccessfulClient({
+        messageListImpl: async () => ({
+          data: [
+            { id: 'msg_idle', type: 'idle', outcome, time: { created: 1_200 } },
+            outcome === 'succeeded' ? erroredAssistant() : completedAssistant(),
+          ],
+        }),
+      });
+      const updateState = vi.fn(async (_projectID, _taskID, state) => ({
+        task: { ...scheduledTask, state: { ...scheduledTask.state, ...state } },
+      }));
+      const runtime = createRuntime(updateState, {
+        runHistoryStore: history,
+        waitForOpenCodeReady: vi.fn(async () => {}),
+        maxRunDurationMs: 2_500,
+      });
+      await runtime.syncProject('project-1');
+      const pending = runtime.runNow('project-1', 'task-1');
+      await vi.advanceTimersByTimeAsync(2_500);
+      const result = await pending;
+      expect(result.status).toBe(status);
+      expect(result.error ?? null).toBe(error);
+      expect(history.finishRun).toHaveBeenCalledWith(
+        expect.any(String), expect.objectContaining({ status }),
+      );
+      expect(client.interrupt).not.toHaveBeenCalled();
+      expect(client.messageList).toHaveBeenCalledTimes(1);
+      expect(history.finishRun.mock.calls[0][1].durationMs).toBeLessThan(2_500);
+      runtime.stop();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('does not settle an older idle record while the session is active', async () => {
+    vi.useFakeTimers();
+    try {
+      const history = createHistoryStore();
+      let busy = true;
+      const client = createSuccessfulClient({
+        activeImpl: async () => busy ? { ses_1: { type: 'running' } } : {},
+        messageListImpl: async () => ({
+          data: [{ id: 'msg_idle', type: 'idle', outcome: 'succeeded', time: { created: 1_200 } }],
+        }),
+      });
+      const runtime = createRuntime(vi.fn(async () => ({ task: scheduledTask })), {
+        runHistoryStore: history,
+        waitForOpenCodeReady: vi.fn(async () => {}),
+        maxRunDurationMs: 5_000,
+      });
+      await runtime.syncProject('project-1');
+      const pending = runtime.runNow('project-1', 'task-1');
+      await vi.advanceTimersByTimeAsync(1_000);
+      expect(history.finishRun).not.toHaveBeenCalled();
+      expect(client.messageList).not.toHaveBeenCalled();
+      busy = false;
+      await vi.advanceTimersByTimeAsync(1_000);
+      expect((await pending).status).toBe('success');
+      runtime.stop();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it('ordinary non-goal runs still create a session and settle on the assistant tail', async () => {
     const history = createHistoryStore();
     const client = createSuccessfulClient({ sessionID: 'ses_plain' });
@@ -1182,16 +1254,17 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     );
   });
 
-  it('does not succeed when the latest message is model-switched', async () => {
+  it.each([
+    { id: 'msg_switch', type: 'model-switched', model: { providerID: 'openai', id: 'gpt-4.1' } },
+    { id: 'msg_idle', type: 'idle', outcome: 'unknown' },
+  ])('does not succeed on an unrecognized terminal: $type', async (tail) => {
     vi.useFakeTimers();
     const history = createHistoryStore();
     createSuccessfulClient({
       messageListImpl: async () => ({
         data: [{
-          id: 'msg_switch',
-          type: 'model-switched',
+          ...tail,
           time: { created: Date.now() },
-          model: { providerID: 'openai', id: 'gpt-4.1' },
         }],
       }),
     });
@@ -1442,7 +1515,7 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     vi.unstubAllGlobals();
   });
 
-  it('corrects lastStatus error → success on idle after a continuation, without rewriting history', async () => {
+  it.each(['assistant', 'idle'])('corrects lastStatus error → success from %s after a continuation, without rewriting history', async (tailType) => {
     const history = createHistoryStore();
     const client = createSuccessfulClient({ settlement: 'assistant-error' });
     const fetchMock = vi.fn(async (url) => {
@@ -1468,7 +1541,9 @@ describe('scheduled-tasks run history and session lifecycle', () => {
     expect(history.finishRun).toHaveBeenCalledTimes(1);
 
     client.messageList.mockImplementation(async () => ({
-      data: [completedAssistant('msg_ok')],
+      data: [tailType === 'idle'
+        ? { id: 'msg_idle', type: 'idle', outcome: 'succeeded', time: { created: 1_200 } }
+        : completedAssistant('msg_ok')],
     }));
 
     await runtime.observeSessionEvent({

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

@@ -186,6 +186,17 @@ before touching the filesystem). Rationale: metadata rides every
 
 ## Flow
 
+Recent-message reads request the newest 40 records with V2 `order: desc`, then
+reverse that page into chronological order for tail checks, audit selection and
+accounting. The SDK and HTTP fallback use the same ordering contract; `asc`
+without a cursor would read the oldest page and strand long sessions after
+compaction. Message IDs are not used to reorder the fetched page.
+
+UI goal removal sends the Merge Patch tombstone `openchamber.goal: null`.
+Omitting the key preserves the stored goal. Objective-file cleanup and stopping
+the active turn follow a successful metadata write; failed writes retain the
+goal and its objective for retry.
+
 1. `createSessionGoalRuntime` subscribes to the global SSE hub (it needs
    the envelope's `directory`).
 2. `session.status: idle` arms a 15s per-session timer; `busy`/`retry` clears

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

@@ -722,20 +722,20 @@ export const createSessionGoalRuntime = ({
       const client = openCodeClient();
       if (typeof client?.message?.list === 'function') {
         const listed = await client.message.list(
-          { sessionID: sessionId, limit: MESSAGE_FETCH_LIMIT, order: 'asc' },
+          { sessionID: sessionId, limit: MESSAGE_FETCH_LIMIT, order: 'desc' },
           directoryRequestOptions(directory),
         );
         const projected = projectGoalMessages(listed, sessionId);
-        if (projected) return projected;
+        if (projected) return projected.reverse();
       }
     } catch {
       // Fall through to controlled HTTP seam for tests / older fixtures.
     }
     const raw = await openCodeFetch(`/session/${encodeURIComponent(sessionId)}/message`, {
       directory,
-      query: { limit: String(MESSAGE_FETCH_LIMIT) },
+      query: { limit: String(MESSAGE_FETCH_LIMIT), order: 'desc' },
     }).catch(() => null);
-    return projectGoalMessages(raw, sessionId);
+    return projectGoalMessages(raw, sessionId)?.reverse() ?? null;
   };
 
   /**

package/server/lib/session-goal/runtime.test.js

@@ -136,7 +136,7 @@ const makeFetch = ({ messages, liveStatus }) => {
       }
       if (pathEndsWith(reqPath, '/session/ses-goal/message')) {
         // Official v2 SessionMessagesResponse shape.
-        return jsonResponse({ data: messages, cursor: {} });
+        return jsonResponse({ data: new URL(url).searchParams.get('order') === 'desc' ? [...messages].reverse() : messages, cursor: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal') && !reqPath.includes('/message')) {
         if (init.method === 'PATCH') {
@@ -263,6 +263,33 @@ describe('session-goal v2 message projection helpers', () => {
 });
 
 describe('session-goal continuation delivery', () => {
+  it.each([false, true])('continues after a completed compaction beyond the first message page (HTTP fallback: %s)', async (fallback) => {
+    const messages = Array.from({ length: 42 }, (_, index) => ({
+      id: `msg_${String(index).padStart(3, '0')}`,
+      type: index === 41 ? 'compaction' : index % 2 ? 'user' : 'assistant',
+      time: index === 41 ? { created: index + 1 } : { created: index + 1, completed: index + 2 },
+      model: { providerID: 'p', id: 'm' },
+      agent: 'build',
+      ...(index === 41 ? { status: 'completed', summary: 'Work remains' } : { text: 'Working' }),
+    }));
+    const fixture = makeFetch({ messages, liveStatus: 'idle' });
+    const runtime = makeRuntime();
+    try {
+      await withFetch(async (input, init) => {
+        const url = new URL(String(input));
+        if (pathEndsWith(url.pathname, '/session/ses-goal/message')) {
+          if (fallback && url.pathname.startsWith('/api/')) return jsonResponse({ error: 'unavailable' }, 503);
+          const ordered = url.searchParams.get('order') === 'desc' ? [...messages].reverse() : messages;
+          return jsonResponse({ data: ordered.slice(0, Number(url.searchParams.get('limit') || 40)), cursor: {} });
+        }
+        return fixture.fetch(input, init);
+      }, async () => runtime.runTick('ses-goal', '/repo'));
+      expect(fixture.calls.prompt).toBe(1);
+    } finally {
+      runtime.stop();
+    }
+  });
+
   it('dispatches v2 session.prompt with stable continuation id and metadata', async () => {
     const promptBodies = [];
     const messages = [
@@ -291,7 +318,7 @@ describe('session-goal continuation delivery', () => {
         return jsonResponse({ data: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal/message')) {
-        return jsonResponse({ data: messages, cursor: {} });
+        return jsonResponse({ data: new URL(url).searchParams.get('order') === 'desc' ? [...messages].reverse() : messages, cursor: {} });
       }
       if (pathEndsWith(reqPath, '/session/ses-goal') && !reqPath.includes('/message')) {
         if (init.method === 'PATCH' && init.body) {
@@ -984,7 +1011,9 @@ describe('session-goal runtime — pause / audit / dispatch boundary', () => {
         const body = Array.isArray(messages)
           ? { data: messages, cursor: {} }
           : messages;
-        return jsonResponse(body);
+        return jsonResponse(new URL(String(input)).searchParams.get('order') === 'desc'
+          ? { ...body, data: [...body.data].reverse() }
+          : body);
       }
       if (pathEndsWith(reqPath, '/session/ses-goal')) {
         if (init.method === 'PATCH') {

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

@@ -1,5 +1,12 @@
 # Session Index Runtime
 
+Native `session.renamed` updates the existing runtime-scoped summary's title and
+update clock directly, publishing through the normal index revision path. It
+preserves activity ordering, pins and execution status; older/duplicate events
+and unknown sessions are no-ops. Partial rename payloads never fabricate rows.
+
+Native `session.moved` uses `data.location.directory`, not the old event-envelope directory. The transactional `move` operation retains summary activity/status and independent pin membership, maintains the newest-20 destination bound, and installs a runtime-scoped event-clock fence against delayed source-directory upserts/pages. Duplicate/older moves are no-ops. Unknown sessions are not fabricated from the partial move payload.
+
 Every OpenChamber Web Server enables `session-index.sqlite` in its data
 directory by default. Electron injects its user-data path explicitly.
 `sessionIndexDbPath` and `OPENCHAMBER_SESSION_INDEX_DB_PATH` override that

package/server/lib/session-index/event-ingest.js

@@ -36,6 +36,19 @@ export const applySessionIndexEvent = (service, event, observedAt = Date.now(),
 
   const baseType = normalizeSessionEventType(payload.type);
 
+  if (baseType === 'session.renamed') {
+    if (isHostReady && !isHostReady()) return false;
+    const data = payload.data ?? properties;
+    return service.rename(data.sessionID, data.title, payload.created ?? properties.eventCreated ?? observedAt);
+  }
+
+  if (baseType === 'session.moved') {
+    const data = payload.data ?? properties;
+    return typeof data.sessionID === 'string' && typeof data.location?.directory === 'string'
+      ? service.move(data.sessionID, data.location.directory, typeof payload.created === 'number' ? payload.created : observedAt, payload.durable?.seq)
+      : false;
+  }
+
   if (baseType === 'session.created' || baseType === 'session.updated') {
     // Until Host metadata is ready, do not write session lifecycle into the
     // index (would bake unprojected upstream archive). Transcript paths use

package/server/lib/session-index/event-ingest.test.js

@@ -3,6 +3,13 @@ import { describe, expect, it, vi } from 'vitest';
 import { applySessionIndexEvent } from './event-ingest.js';
 
 describe('session index event ingest', () => {
+  it('takes moved ownership from native data rather than the old event envelope directory', () => {
+    const service = { move: vi.fn(() => true) };
+    expect(applySessionIndexEvent(service, { directory: '/old', payload: {
+      type: 'session.moved', created: 20, data: { sessionID: 'ses_move', location: { directory: '/new' }, projectID: 'project' },
+    } }, 30)).toBe(true);
+    expect(service.move).toHaveBeenCalledWith('ses_move', '/new', 20, undefined);
+  });
   it('writes session summaries, user activity, and status to the service', () => {
     const service = {
       upsertAndReportChange: vi.fn(() => true),

package/server/lib/session-index/service.js

@@ -277,6 +277,30 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     WHERE runtime_key = ? AND session_id = ?
   `);
 
+  const movedLocations = new Map();
+  const isStaleLocation = (session, directory) => {
+    const moved = movedLocations.get(`${runtimeKey()}:${session?.id}`);
+    return moved && moved.directory !== normalizeDirectory(directory) && toTimestamp(session?.time?.updated) <= moved.at;
+  };
+  const move = db.transaction((sessionID, directory, at = Date.now(), sequence) => {
+    directory = normalizeDirectory(directory);
+    if (!sessionID || !directory) return false;
+    const key = runtimeKey();
+    const fenceKey = `${key}:${sessionID}`;
+    const previous = movedLocations.get(fenceKey);
+    if (previous && (sequence !== undefined && previous.sequence !== undefined
+      ? sequence <= previous.sequence
+      : at < previous.at || (at === previous.at && previous.directory === directory))) return false;
+    movedLocations.set(fenceKey, { directory, at, sequence });
+    touchExistingDirectory.run({ runtimeKey: key, directory, lastAccessedAt: at });
+    const roots = db.prepare('UPDATE OR REPLACE session_summary SET directory = ? WHERE runtime_key = ? AND session_id = ? AND directory != ?').run(directory, key, sessionID, directory);
+    const children = db.prepare('UPDATE OR REPLACE session_child SET directory = ? WHERE runtime_key = ? AND session_id = ? AND directory != ?').run(directory, key, sessionID, directory);
+    db.prepare(`DELETE FROM session_summary WHERE runtime_key = ? AND directory = ? AND session_id IN (
+      SELECT session_id FROM session_summary WHERE runtime_key = ? AND directory = ? ORDER BY activity_updated_at DESC, session_id DESC LIMIT -1 OFFSET ?
+    )`).run(key, directory, key, directory, MAX_ROOT_SESSIONS);
+    return roots.changes > 0 || children.changes > 0;
+  });
+
   const replaceDirectoryRows = ({ directory, sessions, cursor, hasMore, fullSync = true, now = Date.now() }) => {
     const normalizedDirectory = normalizeDirectory(directory);
     if (!normalizedDirectory) throw new Error('directory is required');
@@ -289,6 +313,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     // stale unarchived cache cannot resurrect them.
     const summaries = Array.isArray(sessions)
       ? sessions
+        .filter((session) => !isStaleLocation(session, normalizedDirectory))
         .map((session) => toSummary(session, normalizedDirectory))
         .filter((summary) => summary && !summary.archivedAt)
         .slice(0, MAX_ROOT_SESSIONS)
@@ -328,6 +353,7 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
   });
 
   const upsertMutation = db.transaction((session, now = Date.now(), options = {}) => {
+    if (isStaleLocation(session, session?.directory ?? session?.location?.directory)) return { accepted: false, changed: false };
     if (!isVisibleSession(session)) {
       const changed = remove(session?.id);
       return { accepted: changed, changed };
@@ -517,6 +543,23 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     return result.changes > 0;
   };
 
+  const rename = (sessionID, title, observedAt) => {
+    if (typeof sessionID !== 'string' || !sessionID || typeof title !== 'string') return false;
+    const timestamp = toTimestamp(observedAt);
+    if (!timestamp) return false;
+    const key = runtimeKey();
+    if (HIDDEN_SESSION_TITLES.has(title)) {
+      const current = db.prepare('SELECT updated_at FROM session_summary WHERE runtime_key = ? AND session_id = ?').get(key, sessionID);
+      return current && current.updated_at <= timestamp ? remove(sessionID) : false;
+    }
+    const result = db.prepare(`
+      UPDATE session_summary SET title = ?, updated_at = ?
+      WHERE runtime_key = ? AND session_id = ? AND updated_at <= ?
+        AND (title != ? OR updated_at != ?)
+    `).run(title, timestamp, key, sessionID, timestamp, title, timestamp);
+    return result.changes > 0;
+  };
+
   const updateStatus = (sessionID, status, observedAt) => {
     if (typeof sessionID !== 'string' || !sessionID) return false;
     if (status !== 'busy' && status !== 'retry' && status !== 'idle') return false;
@@ -570,6 +613,8 @@ export const createSessionIndexService = ({ dbPath, getRuntimeConfig = () => nul
     upsertAndReportChange,
     touchActivity,
     updateStatus,
+    rename,
+    move,
     setPinned,
     clearPinned,
     remove,

package/server/lib/session-index/service.test.js

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
 
 import { createSessionIndexService } from './service.js';
+import { applySessionIndexEvent } from './event-ingest.js';
 
 const tempDirectories = [];
 
@@ -31,6 +32,52 @@ afterEach(() => {
 });
 
 describe('Electron session index', () => {
+  it('ingests native renames without changing activity, status, pins or unrelated sessions', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    service.upsert(session('ses_title', 10));
+    service.upsert(session('ses_other', 15));
+    service.setPinned('ses_title', 12);
+    service.updateStatus('ses_title', 'busy', 13);
+    const before = service.snapshot();
+    const rename = (title, created, sessionID = 'ses_title') => applySessionIndexEvent(service, {
+      payload: { type: 'session.renamed', created, data: { sessionID, title } },
+    });
+    expect(rename('Generated title', 20)).toBe(true);
+    const after = service.snapshot();
+    expect(after.directories[0].sessions.map((row) => row.id)).toEqual(before.directories[0].sessions.map((row) => row.id));
+    expect(service.findBySessionId('ses_title')).toMatchObject({ title: 'Generated title' });
+    expect(after.pinnedSessionIds).toEqual(before.pinnedSessionIds);
+    expect(after.directories[0].sessions.find((row) => row.id === 'ses_title').metadata).toEqual(
+      before.directories[0].sessions.find((row) => row.id === 'ses_title').metadata,
+    );
+    expect(rename('Generated title', 20)).toBe(false);
+    expect(rename('Stale title', 19)).toBe(false);
+    expect(rename('Unknown', 30, 'ses_missing')).toBe(false);
+    runtimeRef.value = 'http://runtime-b.test';
+    expect(rename('Other runtime', 30)).toBe(false);
+    service.close();
+  });
+  it('moves one authoritative identity, preserving pin/status and fencing delayed old-directory pages', () => {
+    const runtimeRef = { value: 'http://runtime-a.test' };
+    const service = createService(runtimeRef);
+    service.upsert(session('ses_move', 10, '/old'));
+    service.setPinned('ses_move', 12);
+    service.updateStatus('ses_move', 'retry', 15);
+    expect(service.move('ses_move', '/new', 20)).toBe(true);
+    expect(service.move('ses_move', '/new', 20)).toBe(false);
+    expect(service.move('ses_move', '/old', 19)).toBe(false);
+    service.replaceDirectory({ directory: '/old', sessions: [session('ses_move', 10, '/old')], now: 30 });
+    expect(service.upsertAndReportChange(session('ses_move', 10, '/old'), 40)).toBe(false);
+    const rows = service.snapshot().directories.flatMap((item) => item.sessions);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({ id: 'ses_move', directory: '/new', metadata: { openchamber: { sessionStatus: { type: 'retry' } } } });
+    expect(service.snapshot().pinnedSessionIds).toContain('ses_move');
+    runtimeRef.value = 'http://runtime-b.test';
+    expect(service.upsert(session('ses_move', 1, '/old'))).toBe(true);
+    expect(service.findBySessionId('ses_move').directory).toBe('/old');
+    service.close();
+  });
   it('stores one bounded root-session page transactionally', () => {
     const runtimeRef = { value: 'http://runtime-a.test' };
     const service = createService(runtimeRef);

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

@@ -46,6 +46,12 @@ to match a narrower upstream metadata shape.
 
 ## Contracts
 
+- `openchamber.titleAuthority` is the durable OpenChamber title choice; see
+  `../session-title/DOCUMENTATION.md`. Projection applies a valid same-session
+  authority to list/detail, full session events, and native `session.renamed`
+  events (including replay). Inherited fork authority is ignored. Missing or
+  malformed authority preserves upstream titles and does not lock legacy rows.
+
 - Writes are JSON Merge Patch (RFC 7386): nested objects merge key-by-key; `null` deletes a key.
 - Mutations are fully serialized (read-merge-write + persist) so concurrent writers cannot lose neighbors.
 - Committed `entries` update **only after** successful persist — concurrent readers never observe uncommitted drafts. Persist failure keeps the last committed snapshot and surfaces the error.

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

@@ -53,6 +53,29 @@ describe('mergeMetadataPatch', () => {
 });
 
 describe('createSessionMetadataStore', () => {
+  it('round-trips title authority through the OpenCode record and restart without losing neighboring metadata', async () => {
+    const dataDir = makeDataDir();
+    const record = { id: 'ses_1', title: 'Native', metadata: { plugin: { retained: true } } };
+    const authority = { sessionID: 'ses_1', title: 'Chosen', revision: 'r1', source: 'summary' };
+    const deps = {
+      dataDir,
+      recordReader: async () => structuredClone(record),
+      recordWriter: async (_id, metadata) => { record.metadata = structuredClone(metadata); },
+    };
+    const store = createSessionMetadataStore(deps);
+    await store.mutateSessionMetadata('ses_1', () => ({ ok: true, patch: {
+      openchamber: { titleAuthority: authority },
+    } }));
+    expect(record.metadata).toEqual({ plugin: { retained: true }, openchamber: { titleAuthority: authority } });
+    const reopened = createSessionMetadataStore(deps);
+    expect((await reopened.get('ses_1')).openchamber.titleAuthority).toEqual(authority);
+    expect((await reopened.getAll()).ses_1.openchamber.titleAuthority).toEqual(authority);
+    const stale = await reopened.mutateSessionMetadata('ses_1', (metadata) => ({
+      ok: metadata.openchamber.titleAuthority.revision === 'old', patch: { openchamber: { titleAuthority: null } },
+    }));
+    expect(stale.committed).toBe(false);
+    expect(record.metadata.openchamber.titleAuthority).toEqual(authority);
+  });
   it('starts empty when the file does not exist', async () => {
     const store = createSessionMetadataStore({ dataDir: makeDataDir() });
     await expect(store.getAll()).resolves.toEqual({});

package/server/lib/session-metadata/session-projection.d.ts

@@ -39,3 +39,4 @@ export function projectSessionLifecyclePayload(
   readHostMetadata: (sessionId: string) => unknown,
   options?: { hostReady?: boolean },
 ): unknown;
+export function readSessionTitleAuthority(sessionID: string, metadata: unknown): { sessionID: string; title: string; revision: string; source?: string } | null;

package/server/lib/session-metadata/session-projection.js

@@ -13,6 +13,14 @@
 
 const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
+export const readSessionTitleAuthority = (sessionID, metadata) => {
+  const authority = metadata?.openchamber?.titleAuthority;
+  return typeof sessionID === 'string' && sessionID.length > 0 && authority?.sessionID === sessionID
+    && typeof authority.title === 'string' && authority.title.trim()
+    && typeof authority.revision === 'string' && authority.revision
+    ? authority : null;
+};
+
 /** RFC 7386 merge (local copy — avoid circular import with the metadata store). */
 const mergeMetadataPatch = (current, patch) => {
   const base = isPlainObject(current) ? { ...current } : {};
@@ -33,6 +41,7 @@ const SESSION_LIFECYCLE_BASE = new Set([
   'session.created',
   'session.updated',
   'session.deleted',
+  'session.renamed',
 ]);
 
 /**
@@ -156,8 +165,10 @@ export const projectSessionWithHostMetadata = (session, hostMetadata) => {
   else timeBase.archived = projectedArchived;
 
   const directory = resolveSessionDirectory(session);
+  const titleAuthority = readSessionTitleAuthority(session.id, metadata);
   const next = {
     ...session,
+    ...(titleAuthority ? { title: titleAuthority.title } : {}),
     metadata: Object.keys(metadata).length > 0 ? metadata : (session.metadata ?? metadata),
     time: timeBase,
     ...(directory ? { directory } : {}),
@@ -207,6 +218,15 @@ export const projectSessionWithStoredMap = (session, storedBySessionId) => {
 
 const projectLifecycleInner = (payload, readHostMetadata) => {
   const baseType = normalizeSessionEventType(payload.type);
+  if (baseType === 'session.renamed') {
+    const data = payload.data ?? payload.properties;
+    if (typeof data?.sessionID !== 'string') return payload;
+    const authority = readSessionTitleAuthority(data?.sessionID, readHostMetadata?.(data?.sessionID));
+    if (!authority || data.title === authority.title) return payload;
+    return payload.data
+      ? { ...payload, data: { ...data, title: authority.title } }
+      : { ...payload, properties: { ...data, title: authority.title } };
+  }
   if (baseType !== 'session.created' && baseType !== 'session.updated') return payload;
 
   const info = extractSessionInfoFromPayload(payload);
@@ -267,6 +287,9 @@ export const projectSessionLifecyclePayload = (payload, readHostMetadata, option
   }
 
   const type = typeof payload.type === 'string' ? payload.type : '';
+  if (type === 'session.renamed') {
+    return options.hostReady === false ? null : projectLifecycleInner(payload, readHostMetadata);
+  }
   if (options.hostReady === false && isSessionLifecycleEventType(type)) {
     return null;
   }

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

@@ -5,9 +5,44 @@ import {
   normalizeSessionEventType,
   projectSessionLifecyclePayload,
   resolveSessionDirectory,
+  projectSessionWithHostMetadata,
+  readSessionTitleAuthority,
 } from './session-projection.js';
 
 describe('session projection event shapes', () => {
+  const titleMetadata = { openchamber: { titleAuthority: {
+    sessionID: 'ses_owned', title: 'Chosen title', revision: 'r1', source: 'summary',
+  } } };
+
+  it('keeps the owned title in snapshots and native rename events regardless of upstream clocks', () => {
+    const upstream = { id: 'ses_owned', title: 'Native title', time: { updated: 20 } };
+    expect(projectSessionWithHostMetadata(upstream, titleMetadata).title).toBe('Chosen title');
+    for (const created of [1, 20, 10000]) {
+      const event = { type: 'session.renamed', created, data: { sessionID: 'ses_owned', title: 'Native title' } };
+      expect(projectSessionLifecyclePayload(event, () => titleMetadata)).toEqual({
+        ...event, data: { ...event.data, title: 'Chosen title' },
+      });
+      expect(event.data.title).toBe('Native title');
+    }
+    expect(projectSessionWithHostMetadata({ ...upstream, id: 'ses_fork' }, titleMetadata).title).toBe('Native title');
+  });
+
+  it('suppresses native rename while metadata is unknown, including wrapped replay', () => {
+    const payload = { directory: '/repo', payload: {
+      type: 'session.renamed', data: { sessionID: 'ses_owned', title: 'Native' },
+    } };
+    expect(projectSessionLifecyclePayload(payload, () => null, { hostReady: false })).toBeNull();
+    expect(projectSessionLifecyclePayload(payload, () => titleMetadata).payload.data.title).toBe('Chosen title');
+  });
+
+  it('ignores malformed or absent authority and rename identities', () => {
+    for (const metadata of [undefined, {}, { openchamber: { titleAuthority: {} } }]) {
+      expect(readSessionTitleAuthority(undefined, metadata)).toBeNull();
+      expect(readSessionTitleAuthority('ses_owned', metadata)).toBeNull();
+    }
+    const event = { type: 'session.renamed', data: {} };
+    expect(projectSessionLifecyclePayload(event, () => titleMetadata)).toBe(event);
+  });
   it('normalizes version suffixes', () => {
     expect(normalizeSessionEventType('session.updated.v2')).toBe('session.updated');
     expect(normalizeSessionEventType('session.created')).toBe('session.created');