[codex] polish session list and header follow-ups

hub/src/socket/handlers/cli/sessionHandlers.ts

@@ -1,4 +1,5 @@
 import type { ClientToServerEvents } from '@hapi/protocol'
+import { CodexCollaborationModeSchema, ModelModeSchema, PermissionModeSchema } from '@hapi/protocol/schemas'
 import { z } from 'zod'
 import { randomUUID } from 'node:crypto'
 import type { CodexCollaborationMode, PermissionMode } from '@hapi/protocol/types'
@@ -18,6 +19,7 @@ type SessionAlivePayload = {
     model?: string | null
     effort?: string | null
     collaborationMode?: CodexCollaborationMode
+    modelMode?: import('@hapi/protocol/types').ModelMode
 }
 
 type SessionEndPayload = {
@@ -50,6 +52,18 @@ const updateStateSchema = z.object({
     agentState: z.unknown().nullable()
 })
 
+const sessionAliveSchema = z.object({
+    sid: z.string(),
+    time: z.number(),
+    thinking: z.boolean().optional(),
+    mode: z.enum(['local', 'remote']).optional(),
+    permissionMode: PermissionModeSchema.optional(),
+    model: z.string().nullable().optional(),
+    effort: z.string().nullable().optional(),
+    collaborationMode: CodexCollaborationModeSchema.optional(),
+    modelMode: ModelModeSchema.optional()
+})
+
 export type SessionHandlersDeps = {
     store: Store
     resolveSessionAccess: ResolveSessionAccess
@@ -235,15 +249,17 @@ export function registerSessionHandlers(socket: CliSocketWithData, deps: Session
     socket.on('update-state', handleUpdateState)
 
     socket.on('session-alive', (data: SessionAlivePayload) => {
-        if (!data || typeof data.sid !== 'string' || typeof data.time !== 'number') {
+        const parsed = sessionAliveSchema.safeParse(data)
+        if (!parsed.success) {
             return
         }
-        const sessionAccess = resolveSessionAccess(data.sid)
+        const payload = parsed.data
+        const sessionAccess = resolveSessionAccess(payload.sid)
         if (!sessionAccess.ok) {
-            emitAccessError('session', data.sid, sessionAccess.reason)
+            emitAccessError('session', payload.sid, sessionAccess.reason)
             return
         }
-        onSessionAlive?.(data)
+        onSessionAlive?.(payload)
     })
 
     socket.on('session-end', (data: SessionEndPayload) => {

hub/src/sync/sessionCache.ts

@@ -136,7 +136,8 @@ export class SessionCache {
             model: stored.model,
             effort: stored.effort,
             permissionMode: existing?.permissionMode,
-            collaborationMode: existing?.collaborationMode
+            collaborationMode: existing?.collaborationMode,
+            modelMode: existing?.modelMode
         }
 
         this.sessions.set(sessionId, session)
@@ -160,6 +161,7 @@ export class SessionCache {
         model?: string | null
         effort?: string | null
         collaborationMode?: CodexCollaborationMode
+        modelMode?: Session['modelMode']
     }): void {
         const t = clampAliveTime(payload.time)
         if (!t) return
@@ -173,6 +175,7 @@ export class SessionCache {
         const previousModel = session.model
         const previousEffort = session.effort
         const previousCollaborationMode = session.collaborationMode
+        const previousModelMode = session.modelMode
 
         session.active = true
         session.activeAt = Math.max(session.activeAt, t)
@@ -200,13 +203,17 @@ export class SessionCache {
         if (payload.collaborationMode !== undefined) {
             session.collaborationMode = payload.collaborationMode
         }
+        if (payload.modelMode !== undefined) {
+            session.modelMode = payload.modelMode
+        }
 
         const now = Date.now()
         const lastBroadcastAt = this.lastBroadcastAtBySessionId.get(session.id) ?? 0
         const modeChanged = previousPermissionMode !== session.permissionMode
             || previousModel !== session.model
             || previousEffort !== session.effort
             || previousCollaborationMode !== session.collaborationMode
+            || previousModelMode !== session.modelMode
         const shouldBroadcast = (!wasActive && session.active)
             || (wasThinking !== session.thinking)
             || modeChanged
@@ -224,7 +231,8 @@ export class SessionCache {
                     permissionMode: session.permissionMode,
                     model: session.model,
                     effort: session.effort,
-                    collaborationMode: session.collaborationMode
+                    collaborationMode: session.collaborationMode,
+                    modelMode: session.modelMode
                 }
             })
         }
@@ -266,6 +274,7 @@ export class SessionCache {
             model?: string | null
             effort?: string | null
             collaborationMode?: CodexCollaborationMode
+            modelMode?: Session['modelMode']
         }
     ): void {
         const session = this.sessions.get(sessionId) ?? this.refreshSession(sessionId)
@@ -301,6 +310,9 @@ export class SessionCache {
         if (config.collaborationMode !== undefined) {
             session.collaborationMode = config.collaborationMode
         }
+        if (config.modelMode !== undefined) {
+            session.modelMode = config.modelMode
+        }
 
         this.publisher.emit({ type: 'session-updated', sessionId, data: session })
     }

hub/src/sync/syncEngine.ts

@@ -7,7 +7,13 @@
  * - No E2E encryption; data is stored as JSON in SQLite
  */
 
-import type { CodexCollaborationMode, DecryptedMessage, PermissionMode, Session, SyncEvent } from '@hapi/protocol/types'
+import type {
+    CodexCollaborationMode,
+    DecryptedMessage,
+    PermissionMode,
+    Session,
+    SyncEvent
+} from '@hapi/protocol/types'
 import type { Server } from 'socket.io'
 import type { Store } from '../store'
 import type { RpcRegistry } from '../socket/rpcRegistry'
@@ -42,6 +48,7 @@ export type ResumeSessionResult =
     | { type: 'success'; sessionId: string }
     | { type: 'error'; message: string; code: 'session_not_found' | 'access_denied' | 'no_machine_online' | 'resume_unavailable' | 'resume_failed' }
 
+
 export class SyncEngine {
     private readonly eventPublisher: EventPublisher
     private readonly sessionCache: SessionCache
@@ -97,6 +104,7 @@ export class SyncEngine {
         return this.sessionCache.getSessionsByNamespace(namespace)
     }
 
+
     getSession(sessionId: string): Session | undefined {
         return this.sessionCache.getSession(sessionId) ?? this.sessionCache.refreshSession(sessionId) ?? undefined
     }
@@ -190,6 +198,7 @@ export class SyncEngine {
         model?: string | null
         effort?: string | null
         collaborationMode?: CodexCollaborationMode
+        modelMode?: Session['modelMode']
     }): void {
         this.sessionCache.handleSessionAlive(payload)
     }
@@ -293,9 +302,19 @@ export class SyncEngine {
             model?: string | null
             effort?: string | null
             collaborationMode?: CodexCollaborationMode
+            modelMode?: Session['modelMode']
         }
     ): Promise<void> {
-        const result = await this.rpcGateway.requestSessionConfig(sessionId, config)
+        // modelMode is currently hub-managed metadata only. CLI agents do not yet
+        // accept it through set-session-config RPC, so we apply the validated value
+        // locally after the agent acknowledges the rest of the config.
+        const rpcConfig = {
+            permissionMode: config.permissionMode,
+            model: config.model,
+            effort: config.effort,
+            collaborationMode: config.collaborationMode
+        }
+        const result = await this.rpcGateway.requestSessionConfig(sessionId, rpcConfig)
         if (!result || typeof result !== 'object') {
             throw new Error('Invalid response from session config RPC')
         }
@@ -312,7 +331,10 @@ export class SyncEngine {
             throw new Error('Missing applied session config')
         }
 
-        this.sessionCache.applySessionConfig(sessionId, applied)
+        this.sessionCache.applySessionConfig(sessionId, {
+            ...applied,
+            modelMode: config.modelMode
+        })
     }
 
     async spawnSession(

package.json

@@ -22,6 +22,7 @@
         "test:cli": "cd cli && bun run test",
         "test:hub": "cd hub && bun run test",
         "test:web": "cd web && bun run test",
+        "test:e2e:web": "cd web && bun run test:e2e",
         "clean-session": "bun run hub/scripts/cleanup-sessions.ts",
         "release-all": "cd cli && bun run release-all"
     },

shared/src/modes.ts

@@ -35,6 +35,9 @@ export const PERMISSION_MODES = [
 ] as const
 export type PermissionMode = typeof PERMISSION_MODES[number]
 
+export const MODEL_MODES = ['default', 'sonnet', 'opus'] as const
+export type ModelMode = typeof MODEL_MODES[number]
+
 export const CLAUDE_MODEL_PRESETS = ['sonnet', 'sonnet[1m]', 'opus', 'opus[1m]'] as const
 export type ClaudeModelPreset = typeof CLAUDE_MODEL_PRESETS[number]
 
@@ -82,6 +85,11 @@ export type PermissionModeOption = {
     tone: PermissionModeTone
 }
 
+export type ModelModeOption = {
+    mode: ModelMode
+    label: string
+}
+
 export type CodexCollaborationModeOption = {
     mode: CodexCollaborationMode
     label: string
@@ -94,6 +102,12 @@ export const CLAUDE_MODEL_LABELS: Record<ClaudeModelPreset, string> = {
     'opus[1m]': 'Opus 1M'
 }
 
+export const MODEL_MODE_LABELS: Record<ModelMode, string> = {
+    default: 'Default',
+    sonnet: 'Sonnet',
+    opus: 'Opus'
+}
+
 export const CODEX_COLLABORATION_MODE_LABELS: Record<CodexCollaborationMode, string> = {
     default: 'Default',
     plan: 'Plan'
@@ -152,6 +166,28 @@ export function isPermissionModeAllowedForFlavor(mode: PermissionMode, flavor?:
     return getPermissionModesForFlavor(flavor).includes(mode)
 }
 
+export function getModelModesForFlavor(flavor?: string | null): readonly ModelMode[] {
+    if (flavor === 'codex' || flavor === 'gemini' || flavor === 'opencode' || flavor === 'cursor') {
+        return []
+    }
+    return MODEL_MODES
+}
+
+export function isModelModeAllowedForFlavor(mode: ModelMode, flavor?: string | null): boolean {
+    return getModelModesForFlavor(flavor).includes(mode)
+}
+
+export function getModelModeLabel(mode: ModelMode): string {
+    return MODEL_MODE_LABELS[mode]
+}
+
+export function getModelModeOptionsForFlavor(flavor?: string | null): ModelModeOption[] {
+    return getModelModesForFlavor(flavor).map((mode) => ({
+        mode,
+        label: getModelModeLabel(mode)
+    }))
+}
+
 export function getCodexCollaborationModeOptions(): CodexCollaborationModeOption[] {
     return CODEX_COLLABORATION_MODES.map((mode) => ({
         mode,

shared/src/schemas.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod'
-import { CODEX_COLLABORATION_MODES, PERMISSION_MODES } from './modes'
+import { CODEX_COLLABORATION_MODES, MODEL_MODES, PERMISSION_MODES } from './modes'
 
 export const PermissionModeSchema = z.enum(PERMISSION_MODES)
+export const ModelModeSchema = z.enum(MODEL_MODES)
 export const CodexCollaborationModeSchema = z.enum(CODEX_COLLABORATION_MODES)
-
 const MetadataSummarySchema = z.object({
     text: z.string(),
     updatedAt: z.number()
@@ -177,6 +177,7 @@ export const SessionSchema = z.object({
     model: z.string().nullable(),
     effort: z.string().nullable(),
     permissionMode: PermissionModeSchema.optional(),
+    modelMode: ModelModeSchema.optional(),
     collaborationMode: CodexCollaborationModeSchema.optional()
 })
 
@@ -236,7 +237,7 @@ export const SyncEventSchema = z.discriminatedUnion('type', [
             status: z.string(),
             subscriptionId: z.string().optional()
         }).optional()
-    })
+    }),
 ])
 
 export type SyncEvent = z.infer<typeof SyncEventSchema>

shared/src/sessionSummary.ts

@@ -1,3 +1,4 @@
+import type { ModelMode, PermissionMode } from './modes'
 import type { Session, WorktreeMetadata } from './schemas'
 
 export type SessionSummaryMetadata = {
@@ -20,6 +21,8 @@ export type SessionSummary = {
     pendingRequestsCount: number
     model: string | null
     effort: string | null
+    permissionMode?: PermissionMode
+    modelMode?: ModelMode
 }
 
 export function toSessionSummary(session: Session): SessionSummary {
@@ -49,6 +52,8 @@ export function toSessionSummary(session: Session): SessionSummary {
         todoProgress,
         pendingRequestsCount,
         model: session.model,
-        effort: session.effort
+        effort: session.effort,
+        permissionMode: session.permissionMode,
+        modelMode: session.modelMode
     }
 }

shared/src/types.ts

@@ -28,6 +28,8 @@ export type {
     GeminiPermissionMode,
     OpencodePermissionMode,
     ClaudeModelPreset,
+    ModelMode,
+    ModelModeOption,
     PermissionMode,
     PermissionModeOption,
     PermissionModeTone