tiann
diff --git a/‎cli/src/codex/session.ts‎
Lines changed: 10 additions & 3 deletions b/‎cli/src/codex/session.ts‎
Lines changed: 10 additions & 3 deletions
diff --git a/‎hub/src/socket/handlers/cli/sessionHandlers.test.ts‎
Lines changed: 60 additions & 4 deletions b/‎hub/src/socket/handlers/cli/sessionHandlers.test.ts‎
Lines changed: 60 additions & 4 deletions
diff --git a/‎hub/src/socket/handlers/cli/sessionHandlers.ts‎
Lines changed: 7 additions & 1 deletion b/‎hub/src/socket/handlers/cli/sessionHandlers.ts‎
Lines changed: 7 additions & 1 deletion
@@ -102,9 +102,16 @@ export class CodexSession extends AgentSessionBase<EnhancedMode> {
         this.sessionId = null;
         this.resetTranscriptPath();
         this.client.updateMetadata((metadata: Metadata) => {
-            const updated = { ...metadata };
-            delete updated.codexSessionId;
-            return updated;
+            // Explicit-clear sentinel: `null` instructs the hub merge to
+            // drop `codexSessionId` from the persisted blob. Plain
+            // `delete` arrives at the hub as an omitted field, which the
+            // carry-forward path then restores from the prior row —
+            // defeating the reset. See hub/src/store/sessions.ts
+            // mergeSessionMetadata. The value is `null` on the wire only;
+            // MetadataSchema parses `string().optional()`, so the
+            // post-merge persisted blob carries no key.
+            const updated: Record<string, unknown> = { ...metadata, codexSessionId: null };
+            return updated as unknown as Metadata;
         });
     }
 
 
@@ -6,9 +6,9 @@ import { registerSessionHandlers } from './sessionHandlers'
 
 class FakeSocket {
     readonly roomEvents: Array<{ room: string; event: string; data: unknown }> = []
-    private readonly handlers = new Map<string, (data: unknown) => void>()
+    private readonly handlers = new Map<string, (data: unknown, ack?: (response: unknown) => void) => void>()
 
-    on(event: string, handler: (data: unknown) => void): this {
+    on(event: string, handler: (data: unknown, ack?: (response: unknown) => void) => void): this {
         this.handlers.set(event, handler)
         return this
     }
@@ -21,8 +21,8 @@ class FakeSocket {
         }
     }
 
-    trigger(event: string, data: unknown): void {
-        this.handlers.get(event)?.(data)
+    trigger(event: string, data: unknown, ack?: (response: unknown) => void): void {
+        this.handlers.get(event)?.(data, ack)
     }
 }
 
@@ -64,4 +64,60 @@ describe('cli session handlers', () => {
         expect(socket.roomEvents).toHaveLength(0)
         expect(webEvents).toHaveLength(0)
     })
+
+    it('update-metadata broadcasts the merged value, not the pre-merge payload', () => {
+        const store = new Store(':memory:')
+        const session = store.sessions.getOrCreateSession(
+            'broadcast-merged',
+            {
+                path: '/tmp/project',
+                host: 'example',
+                cursorSessionId: 'broadcast-survives'
+            },
+            null,
+            'default'
+        )
+        const socket = new FakeSocket()
+
+        registerSessionHandlers(socket as unknown as CliSocketWithData, {
+            store,
+            resolveSessionAccess: () => ({ ok: true, value: session as StoredSession }),
+            emitAccessError: () => {
+                throw new Error('unexpected access error')
+            }
+        })
+
+        let ackResponse: unknown = null
+        socket.trigger(
+            'update-metadata',
+            {
+                sid: session.id,
+                expectedVersion: session.metadataVersion,
+                metadata: {
+                    lifecycleState: 'archived',
+                    archivedBy: 'cli',
+                    archiveReason: 'Session crashed'
+                }
+            },
+            (response) => {
+                ackResponse = response
+            }
+        )
+
+        // Ack: success and the version bumps; the persisted value carries the
+        // merged metadata so other CLIs can update their cache to the truth.
+        const ack = ackResponse as { result: string; version: number; metadata: unknown }
+        expect(ack.result).toBe('success')
+        const ackMetadata = ack.metadata as Record<string, unknown>
+        expect(ackMetadata.cursorSessionId).toBe('broadcast-survives')
+        expect(ackMetadata.path).toBe('/tmp/project')
+
+        // Broadcast: the room event must carry the same merged value.
+        const broadcast = socket.roomEvents.find((event) => event.event === 'update')
+        expect(broadcast).toBeDefined()
+        const broadcastBody = (broadcast?.data as { body: { metadata: { value: Record<string, unknown> } } }).body
+        expect(broadcastBody.metadata.value.cursorSessionId).toBe('broadcast-survives')
+        expect(broadcastBody.metadata.value.path).toBe('/tmp/project')
+        expect(broadcastBody.metadata.value.lifecycleState).toBe('archived')
+    })
 })
@@ -202,7 +202,13 @@ export function registerSessionHandlers(socket: CliSocketWithData, deps: Session
                 body: {
                     t: 'update-session' as const,
                     sid,
-                    metadata: { version: result.version, value: metadata },
+                    // Broadcast the persisted (merged) value, not the pre-merge
+                    // payload — otherwise other CLIs in the session room would
+                    // overwrite their local cache with a tokenless metadata
+                    // snapshot even though the DB row was preserved.
+                    // See store.sessions.mergeSessionMetadata for the merge
+                    // contract.
+                    metadata: { version: result.version, value: result.value },
                     agentState: null
                 }
             }