@openchambery/web 2.0.0-beta.3 → 2.0.0-beta.31

package/server/lib/session-metadata/opencode-session-record.test.js

@@ -0,0 +1,242 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSessionArchiveService } from './session-archive.js';
+import { createSessionMetadataStore } from './session-metadata-store.js';
+import {
+  createHttpSessionRecordClient,
+  mergeOwnedMetadata,
+  migrateLoadedSideStore,
+  readSessionRecordViaClient,
+  retainOpenCodeSessions,
+  writeSessionRecordViaClient,
+} from './opencode-session-record.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const makeDataDir = () => fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-record-'));
+
+describe('OpenCode session record ownership', () => {
+  it('keeps title and archive on the OpenCode record across archive and restore', async () => {
+    const dataDir = makeDataDir();
+    const records = new Map([
+      ['ses_1', {
+        id: 'ses_1',
+        title: 'Keep me',
+        metadata: { openchamber: { goal: { status: 'active' }, assistant: { assistantID: 'ast_1' } } },
+        time: { created: 1, updated: 2 },
+      }],
+    ]);
+    const writes = [];
+    const store = createSessionMetadataStore({
+      dataDir,
+      recordReader: async (sessionID) => records.get(sessionID) ?? null,
+      recordWriter: async (sessionID, metadata) => {
+        const current = records.get(sessionID);
+        if (!current) {
+          const error = new Error('missing');
+          error.status = 404;
+          throw error;
+        }
+        writes.push({ sessionID, metadata, title: current.title });
+        records.set(sessionID, { ...current, metadata });
+      },
+    });
+    const archive = createSessionArchiveService({
+      sessionMetadataStore: store,
+      fetchUpstreamSession: async ({ sessionID }) => records.get(sessionID) ?? null,
+    });
+
+    const archived = await archive.setArchive({ sessionID: 'ses_1', archivedAt: 50, directory: '/repo' });
+    expect(archived.session.title).toBe('Keep me');
+    expect(archived.session.time.archived).toBe(50);
+    expect(records.get('ses_1').title).toBe('Keep me');
+    expect(records.get('ses_1').metadata.openchamber.archive.archivedAt).toBe(50);
+    expect(records.get('ses_1').metadata.openchamber.goal.status).toBe('active');
+    expect(records.get('ses_1').metadata.openchamber.assistant.assistantID).toBe('ast_1');
+    expect(writes.at(-1).metadata.openchamber.assistant.assistantID).toBe('ast_1');
+
+    const restored = await archive.setArchive({ sessionID: 'ses_1', archivedAt: 0 });
+    expect(restored.session.title).toBe('Keep me');
+    expect(restored.session.time.archived).toBeUndefined();
+    expect(records.get('ses_1').title).toBe('Keep me');
+    expect(records.get('ses_1').metadata.openchamber.archive.archivedAt).toBe(0);
+    expect(records.get('ses_1').metadata.openchamber.goal.status).toBe('active');
+
+    const restarted = createSessionMetadataStore({
+      dataDir: makeDataDir(),
+      recordReader: async (sessionID) => records.get(sessionID) ?? null,
+      recordWriter: async () => undefined,
+    });
+    await expect(restarted.get('ses_1')).resolves.toMatchObject({
+      openchamber: {
+        archive: { archivedAt: 0 },
+        goal: { status: 'active' },
+        assistant: { assistantID: 'ast_1' },
+      },
+    });
+    const visible = retainOpenCodeSessions([records.get('ses_1')], {});
+    expect(visible).toHaveLength(1);
+    expect(visible[0].title).toBe('Keep me');
+    expect(visible[0].time.archived).toBeUndefined();
+  });
+
+  it('does not drop an OpenCode session when the side store has no row', () => {
+    const visible = retainOpenCodeSessions([
+      {
+        id: 'ses_1',
+        title: 'Still here',
+        metadata: { openchamber: { archive: { archivedAt: 9 } } },
+        time: { created: 1, updated: 2 },
+      },
+      { id: 'ses_2', title: 'Also here', time: { created: 1, updated: 2 } },
+    ], {});
+
+    expect(visible.map((session) => session.id)).toEqual(['ses_1', 'ses_2']);
+    expect(visible[0].title).toBe('Still here');
+    expect(visible[0].time.archived).toBe(9);
+    expect(visible[1].title).toBe('Also here');
+  });
+
+  it('does not treat an unread side store as an empty catalog', () => {
+    expect(() => retainOpenCodeSessions([{ id: 'ses_1', title: 'Stay' }], null)).toThrow(/unavailable/);
+    expect(() => retainOpenCodeSessions(null, {})).toThrow(/unavailable/);
+  });
+
+  it('does not treat a failed side-store load as an authoritative empty migration', async () => {
+    const writes = [];
+    const records = {
+      ses_1: { id: 'ses_1', title: 'Stay', metadata: { openchamber: { goal: { id: 'g1' } } } },
+    };
+    const result = await migrateLoadedSideStore({
+      loadResult: { ok: false, entries: {} },
+      readSession: async (id) => records[id] ?? null,
+      writeMetadata: async (id, metadata) => {
+        writes.push(id);
+        records[id] = { ...records[id], metadata };
+      },
+    });
+
+    expect(result.status).toBe('unavailable');
+    expect(writes).toEqual([]);
+    expect(records.ses_1.title).toBe('Stay');
+    expect(records.ses_1.metadata.openchamber.goal.id).toBe('g1');
+  });
+
+  it('keeps other sessions when one migration write fails', async () => {
+    const records = {
+      ses_ok: { id: 'ses_ok', title: 'Ok', metadata: {} },
+      ses_bad: { id: 'ses_bad', title: 'Bad', metadata: { openchamber: { llm: { purpose: 'keep' } } } },
+      ses_only_opencode: { id: 'ses_only_opencode', title: 'Stay', metadata: { fromOpenCode: true } },
+    };
+    const side = {
+      ses_ok: { openchamber: { goal: { id: 'g1' } } },
+      ses_bad: { openchamber: { assistant: { assistantID: 'ast_1' } } },
+    };
+
+    const result = await migrateLoadedSideStore({
+      loadResult: { ok: true, entries: side },
+      readSession: async (id) => records[id] ?? null,
+      writeMetadata: async (id, metadata) => {
+        if (id === 'ses_bad') throw new Error('write failed');
+        records[id] = { ...records[id], metadata };
+      },
+    });
+
+    expect(result.status).toBe('partial');
+    expect(result.migrated).toEqual(['ses_ok']);
+    expect(result.failed).toEqual([{ id: 'ses_bad', error: 'write failed' }]);
+    expect(records.ses_ok.metadata.openchamber.goal.id).toBe('g1');
+    expect(records.ses_ok.title).toBe('Ok');
+    expect(records.ses_bad.title).toBe('Bad');
+    expect(records.ses_bad.metadata.openchamber.llm.purpose).toBe('keep');
+    expect(records.ses_bad.metadata.openchamber.assistant).toBeUndefined();
+    expect(records.ses_only_opencode).toEqual({
+      id: 'ses_only_opencode',
+      title: 'Stay',
+      metadata: { fromOpenCode: true },
+    });
+    expect(side.ses_bad.openchamber.assistant.assistantID).toBe('ast_1');
+  });
+
+  it('fills side-store gaps without letting an empty side row wipe OpenCode fields', () => {
+    expect(mergeOwnedMetadata(
+      { openchamber: { goal: { status: 'paused' } }, fromOpenCode: true },
+      { openchamber: { goal: { id: 'g1' }, archive: { archivedAt: 4 } } },
+    )).toEqual({
+      fromOpenCode: true,
+      openchamber: { goal: { id: 'g1', status: 'paused' }, archive: { archivedAt: 4 } },
+    });
+    expect(mergeOwnedMetadata({ keep: true }, {})).toEqual({ keep: true });
+    expect(mergeOwnedMetadata({ keep: true }, null)).toEqual({ keep: true });
+  });
+
+  it('throws when the installed client has no session.update instead of writing nothing', async () => {
+    await expect(writeSessionRecordViaClient({ session: {} }, {
+      sessionID: 'ses_1',
+      metadata: { openchamber: { archive: { archivedAt: 1 } } },
+    })).rejects.toThrow(/session\.update is unavailable/);
+  });
+
+  it('writes metadata through session.update without sending title', async () => {
+    const update = vi.fn(async () => undefined);
+    await writeSessionRecordViaClient({ session: { update } }, {
+      sessionID: 'ses_1',
+      metadata: { openchamber: { archive: { archivedAt: 3 } } },
+    });
+    expect(update).toHaveBeenCalledWith({
+      sessionID: 'ses_1',
+      metadata: { openchamber: { archive: { archivedAt: 3 } } },
+    }, undefined);
+    expect(update.mock.calls[0][0].title).toBeUndefined();
+  });
+
+  it('reads a missing session as not-found and a transport failure as failure', async () => {
+    const missing = Object.assign(new Error('gone'), { status: 404 });
+    await expect(readSessionRecordViaClient({
+      session: { get: async () => { throw missing; } },
+    }, { sessionID: 'ses_1' })).resolves.toBeNull();
+
+    const down = Object.assign(new Error('down'), { status: 503 });
+    await expect(readSessionRecordViaClient({
+      session: { get: async () => { throw down; } },
+    }, { sessionID: 'ses_1' })).rejects.toThrow(/down/);
+  });
+
+  it('patches the session record over HTTP and does not turn a failed read into an empty session', async () => {
+    const calls = [];
+    const fetchFn = vi.fn(async (url, init) => {
+      calls.push({ url, method: init.method, body: init.body ? JSON.parse(init.body) : undefined });
+      if (init.method === 'PATCH' && String(url).includes('ses_ok')) {
+        return { ok: true, status: 204, json: async () => null };
+      }
+      if (String(url).includes('ses_missing')) {
+        return { ok: false, status: 404, json: async () => ({}) };
+      }
+      if (String(url).includes('ses_down')) {
+        return { ok: false, status: 503, json: async () => ({}) };
+      }
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ id: 'ses_ok', title: 'Keep', metadata: { fromOpenCode: true } }),
+      };
+    });
+    const client = createHttpSessionRecordClient({
+      buildSessionUrl: (sessionID) => `http://opencode.local/api/session/${sessionID}`,
+      fetchFn,
+    });
+
+    await expect(client.read('ses_ok')).resolves.toMatchObject({ id: 'ses_ok', title: 'Keep' });
+    await expect(client.read('ses_missing')).resolves.toBeNull();
+    await expect(client.read('ses_down')).rejects.toThrow(/503/);
+    await client.write({
+      sessionID: 'ses_ok',
+      metadata: { openchamber: { archive: { archivedAt: 8 } } },
+    });
+
+    const patch = calls.find((call) => call.method === 'PATCH');
+    expect(patch.body).toEqual({ metadata: { openchamber: { archive: { archivedAt: 8 } } } });
+    expect(patch.body.title).toBeUndefined();
+  });
+});

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

@@ -83,13 +83,17 @@ export const registerSessionMetadataRoutes = (app, deps = {}) => {
               },
             },
           };
+        }, {
+          directory: asNonEmptyString(body.directory) || undefined,
         });
         if (!result?.committed) {
           throw new Error(result?.reason || 'session metadata mutate was rejected');
         }
         metadata = result.metadata;
       } else {
-        metadata = await sessionMetadataStore.setSessionMetadata(sessionId, patch);
+        metadata = await sessionMetadataStore.setSessionMetadata(sessionId, patch, {
+          directory: asNonEmptyString(body.directory) || undefined,
+        });
       }
       const directory = asNonEmptyString(body.directory) || '';
       if (typeof onMetadataWritten === 'function') {

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

@@ -451,7 +451,7 @@ export const createSessionArchiveService = (deps = {}) => {
     const metadata = await sessionMetadataStore.setSessionMetadata(
       sessionID,
       { openchamber: { archive: { archivedAt } } },
-      { allowArchive: true },
+      { allowArchive: true, directory: upstreamDirectory || directoryHint },
     );
 
     // New Host mutation wins: bump generation and cancel older repair timers

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

@@ -33,4 +33,6 @@ export function createSessionMetadataStore(options: {
   fsPromises?: typeof import('node:fs').promises;
   path?: typeof import('node:path');
   now?: () => number;
+  recordReader?: (sessionID: string, directory?: string | null) => Promise<object | null>;
+  recordWriter?: (sessionID: string, metadata: object, directory?: string | null) => Promise<void>;
 }): SessionMetadataStore;

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

@@ -1,26 +1,28 @@
 /**
- * OpenChamber-owned session metadata.
+ * OpenChamber session metadata cache and migration source.
  *
- * OpenCode 2.x accepts `metadata` only when a session is created; the v1
- * `PATCH /session/{id}` route is gone and nothing replaces it. Session goal
- * progress (and later assist / pinned notes) live here: one JSON file per data
- * dir, `{ [sessionID]: metadata }`, folded back onto the sessions the proxy
- * serves so clients keep reading `session.metadata` where they always did.
+ * The OpenCode session record is the durable authority for title, archive, and
+ * other OpenChamber metadata (`opencode-session-record.js`). This JSON file
+ * remains the cache and the pre-migration source. A failed or corrupt read is
+ * never empty success: the store stays unwritable and does not overwrite
+ * unknown disk state or the OpenCode record.
  *
  * Writes are a JSON Merge Patch (RFC 7386): nested objects merge key by key and
- * a `null` deletes. That is what the old PATCH did, and it is what keeps two
- * features writing into the same `openchamber` namespace from erasing each
- * other — goal mode saving progress must not drop an assist recap.
+ * a `null` deletes. That keeps two features writing into the same `openchamber`
+ * namespace from erasing each other — goal mode saving progress must not drop
+ * an assist recap. When a record reader and writer are wired, the merged object
+ * is written onto the OpenCode session before the local cache commits. A failed
+ * record read is not treated as empty metadata.
  *
  * Mutations are fully serialized. Committed `entries` update only after a
  * successful persist so concurrent readers never observe uncommitted drafts.
- * A failed or corrupt file read is never empty success: the store stays
- * unwritable and reports the error instead of overwriting unknown disk state.
  */
 
 import fsDefault from 'node:fs';
 import pathDefault from 'node:path';
 
+import { mergeOwnedMetadata } from './opencode-session-record.js';
+
 const METADATA_FILE_NAME = 'sessions-metadata.json';
 const HOST_ARCHIVE_KEY = 'archive';
 
@@ -103,13 +105,22 @@ const applyReservedArchiveProtection = (previous, patch, merged, { allowArchive
  * @param {typeof fsDefault.promises} [options.fsPromises]
  * @param {typeof pathDefault} [options.path]
  * @param {() => number} [options.now]
+ * @param {(sessionID: string, directory?: string | null) => Promise<object | null>} [options.recordReader]
+ *   OpenCode session read. Null means the session is gone. Any other failure throws.
+ * @param {(sessionID: string, metadata: object, directory?: string | null) => Promise<void>} [options.recordWriter]
+ *   Writes the full merged metadata onto the OpenCode session record. Must not send title.
  */
 export const createSessionMetadataStore = ({
   dataDir,
   fsPromises = fsDefault.promises,
   path = pathDefault,
   now = Date.now,
+  recordReader = null,
+  recordWriter = null,
 }) => {
+  if (typeof recordWriter === 'function' && typeof recordReader !== 'function') {
+    throw new Error('session record writer requires a record reader');
+  }
   const filePath = path.join(dataDir, METADATA_FILE_NAME);
 
   /** sessionID → metadata. Committed only — never holds an in-flight draft. */
@@ -218,11 +229,27 @@ export const createSessionMetadataStore = ({
     return next;
   };
 
-  const get = async (sessionID) => {
+  const readRecordMetadata = async (id, directory) => {
+    if (typeof recordReader !== 'function') return undefined;
+    try {
+      const record = await recordReader(id, directory);
+      if (record == null) return null;
+      return isPlainObject(record.metadata) ? record.metadata : {};
+    } catch (error) {
+      if (entries.has(id)) return undefined;
+      throw error;
+    }
+  };
+
+  const get = async (sessionID, options = {}) => {
     const id = asNonEmptyString(sessionID);
     if (!id) return {};
     await ensureReadable();
-    return entries.get(id) ?? {};
+    const side = entries.get(id);
+    const fromRecord = await readRecordMetadata(id, options.directory);
+    if (fromRecord === undefined) return side ?? {};
+    if (fromRecord === null) return side ?? {};
+    return mergeOwnedMetadata(fromRecord, side);
   };
 
   const has = async (sessionID) => {
@@ -243,16 +270,36 @@ export const createSessionMetadataStore = ({
    */
   const commitMergedPatch = async (id, previous, patch, options = {}) => {
     const allowArchive = options.allowArchive === true;
+    let base = previous;
+    if (typeof recordReader === 'function') {
+      let record;
+      try {
+        record = await recordReader(id, options.directory);
+      } catch (error) {
+        // A failed read is not an empty record. Do not replace metadata we could not see.
+        throw error;
+      }
+      if (record == null) {
+        const error = new Error(`session ${id} was not found`);
+        error.status = 404;
+        throw error;
+      }
+      base = mergeOwnedMetadata(record.metadata, previous);
+    }
     const effectivePatch = allowArchive ? patch : stripArchiveFromMetadataPatch(patch);
 
-    let merged = mergeMetadataPatch(previous, effectivePatch);
-    merged = applyReservedArchiveProtection(previous, patch, merged, { allowArchive });
+    let merged = mergeMetadataPatch(base, effectivePatch);
+    merged = applyReservedArchiveProtection(base, patch, merged, { allowArchive });
+
+    if (typeof recordWriter === 'function') {
+      await recordWriter(id, merged, options.directory);
+    }
 
     const nextMap = new Map(entries);
     if (Object.keys(merged).length === 0) nextMap.delete(id);
     else nextMap.set(id, merged);
 
-    // Persist draft snapshot first; publish to committed entries only on success.
+    // OpenCode write already landed. Publish the local cache only after its persist succeeds.
     await persistMap(nextMap);
 
     if (Object.keys(merged).length === 0) entries.delete(id);

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 } : {}),
@@ -168,6 +179,30 @@ export const projectSessionWithHostMetadata = (session, hostMetadata) => {
   return next;
 };
 
+/**
+ * OpenCode record keys win. Side-store keys the record does not have yet are
+ * filled in. A missing or empty side row does not wipe the record.
+ *
+ * @param {unknown} openCodeMetadata
+ * @param {unknown} sideMetadata
+ */
+export const mergeOwnedMetadata = (openCodeMetadata, sideMetadata) => {
+  const openCode = isPlainObject(openCodeMetadata) ? openCodeMetadata : {};
+  if (!isPlainObject(sideMetadata) || Object.keys(sideMetadata).length === 0) {
+    return { ...openCode };
+  }
+  return mergeMetadataPatch(sideMetadata, openCode);
+};
+
+const projectRecordMetadata = (session, sideMetadata) => {
+  const metadata = mergeOwnedMetadata(session.metadata, sideMetadata);
+  const hadMetadata = isPlainObject(session.metadata);
+  const withRecord = Object.keys(metadata).length === 0 && !hadMetadata
+    ? session
+    : { ...session, metadata };
+  return projectSessionWithHostMetadata(withRecord, null);
+};
+
 /**
  * @param {object | null | undefined} session
  * @param {Record<string, object> | null | undefined} storedBySessionId
@@ -178,11 +213,20 @@ export const projectSessionWithStoredMap = (session, storedBySessionId) => {
     return projectSessionWithHostMetadata(session, null);
   }
   const host = storedBySessionId[session.id];
-  return projectSessionWithHostMetadata(session, isPlainObject(host) ? host : null);
+  return projectRecordMetadata(session, isPlainObject(host) ? host : null);
 };
 
 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);
@@ -196,7 +240,7 @@ const projectLifecycleInner = (payload, readHostMetadata) => {
       host = null;
     }
   }
-  const projected = projectSessionWithHostMetadata(info, isPlainObject(host) ? host : null);
+  const projected = projectRecordMetadata(info, isPlainObject(host) ? host : null);
   if (projected === info) return payload;
 
   const next = { ...payload };
@@ -243,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');