@@ -13,6 +13,7 @@ import {
   patchBotsByBotIdAcpRuntimesByRuntimeIdMode,
   patchBotsByBotIdAcpRuntimesByRuntimeIdReasoning,
   patchBotsByBotIdSessionsBySessionId,
+  getBotsByBotIdSessionsModelPreferenceSeed,
   patchBotsByBotIdSessionsBySessionIdAcpRuntimeMode,
   patchBotsByBotIdSessionsBySessionIdAcpRuntimeModel,
   patchBotsByBotIdSessionsBySessionIdAcpRuntimeReasoning,
@@ -35,6 +36,14 @@ export interface CreateSessionOptions {
    * workdir pins the session's workspace target and working directory.
    */
   workdirId?: string
+  /**
+   * First-send picker pair (issue #879). Carried only when the pair has an
+   * explicit source (user pick / remembered session); when omitted the
+   * session is born with NULL preference columns and follows the bot default.
+   * The server reconciles both before the INSERT.
+   */
+  preferredChatModelId?: string
+  preferredReasoningEffort?: string
 }
 
 export interface CreateACPRuntimeOptions {
@@ -117,6 +126,8 @@ export async function createSession(botId: string, options?: string | CreateSess
         runtime_metadata: options?.runtimeMetadata,
         acp_runtime_id: options?.acpRuntimeId?.trim() || undefined,
         workdir_id: options?.workdirId?.trim() || undefined,
+        preferred_chat_model_id: options?.preferredChatModelId?.trim() || undefined,
+        preferred_reasoning_effort: options?.preferredReasoningEffort?.trim() || undefined,
       }
   const { data } = await postBotsByBotIdSessions({
     path: { bot_id: id },
@@ -158,6 +169,38 @@ export async function updateSessionTitle(botId: string, sessionId: string, title
   return data as SessionSummary
 }
 
+// Picker pair persistence (issue #879): best-effort PATCH from the composer.
+// The caller treats failures as silent — the next sent message writes the
+// resolved pair back server-side, so a dropped PATCH only loses the
+// pick-until-send window.
+export async function updateSessionModelPreference(botId: string, sessionId: string, modelId: string, reasoningEffort: string, expectedRevision: string): Promise<SessionSummary> {
+  const { data } = await patchBotsByBotIdSessionsBySessionId({
+    path: { bot_id: botId.trim(), session_id: sessionId.trim() },
+    body: {
+      expected_model_preference_revision: expectedRevision,
+      preferred_chat_model_id: modelId,
+      preferred_reasoning_effort: reasoningEffort,
+    },
+    throwOnError: true,
+  })
+  return data as SessionSummary
+}
+
+export interface ModelPreferenceSeed {
+  model_id?: string
+  reasoning_effort?: string
+}
+
+// Welcome composer seed (issue #879): the pair of the bot's most recent
+// native session. Empty fields mean "no seed" — fall back to the bot default.
+export async function fetchModelPreferenceSeed(botId: string): Promise<ModelPreferenceSeed> {
+  const { data } = await getBotsByBotIdSessionsModelPreferenceSeed({
+    path: { bot_id: botId.trim() },
+    throwOnError: true,
+  })
+  return data as ModelPreferenceSeed
+}
+
 export interface UpdateSessionAgentOptions {
   botAgentId?: string
   type?: string
 
@@ -21,6 +21,11 @@ export interface SessionSummary {
   updated_at?: string
   route_metadata?: Record<string, unknown>
   route_conversation_type?: string
+  /** Session's persisted (model, effort) pair (issue #879); empty = no memory. */
+  preferred_external_model_id?: string
+  model_preference_revision?: string
+  preferred_chat_model_id?: string
+  preferred_reasoning_effort?: string
 }
 
 // Bot-wide activity SSE: `/bots/{bot_id}/sessions/events`. Carries identifier
@@ -520,7 +525,15 @@ export type UIRuntimeEvent =
   | UIRuntimeDeltaEvent
   | UIRuntimeDroppedEvent
 
+export interface UIStreamModelPreferenceSettledEvent {
+  type: 'model_preference_settled'
+  invocation_id: string
+  run_id: string
+  session_id: string
+}
+
 export type UIStreamEvent =
+  | UIStreamModelPreferenceSettledEvent
   | UIStreamRunAcceptedEvent
   | UIStreamRunRejectedEvent
   | UIStreamErrorEvent
 
@@ -222,6 +222,16 @@ describe('useChat.ws', () => {
     expect(third.sent).toEqual([])
   })
 
+  it('forwards preference settlement before the response completes', () => {
+    const onStreamEvent = vi.fn()
+    connectWebSocket('bot-1', onStreamEvent)
+    const socket = MockWebSocket.instances[0]!
+    socket.open()
+    const event = { type: 'model_preference_settled', invocation_id: 'inv', run_id: 'run', session_id: 'session' }
+    socket.emit(event)
+    expect(onStreamEvent).toHaveBeenCalledWith(event)
+  })
+
   it('uses the configured absolute API base URL', () => {
     client.setConfig({ baseUrl: 'http://127.0.0.1:18080' })
     vi.stubGlobal('localStorage', {
 
@@ -234,6 +234,7 @@ export function connectWebSocket(
         const eventType = String(parsed.type ?? '').trim()
         if (
           eventType !== 'run_accepted'
+          && eventType !== 'model_preference_settled'
           && eventType !== 'run_rejected'
           && eventType !== 'error'
           && eventType !== 'session_created'
 
@@ -230,6 +230,9 @@
       "runtime_busy": "Wait for the current response to finish before switching Agent accounts.",
       "materialization_failed": "The Agent account could not be prepared. Please retry."
     },
+    "session": {
+      "model_preference_conflict": "The model selection changed elsewhere. Refresh or send your message to apply your selection."
+    },
     "session_runtime": {
       "session_busy": "This conversation is still working on your previous message. Please try again in a moment.",
       "invocation_conflict": "This message was already sent with different content. Reload the conversation to see what was saved.",
 
@@ -227,6 +227,9 @@
       "runtime_busy": "現在の応答が完了してから Agent アカウントを切り替えてください。",
       "materialization_failed": "Agent アカウントを準備できませんでした。もう一度お試しください。"
     },
+    "session": {
+      "model_preference_conflict": "モデルの選択が別の場所で更新されました。再読み込みするか、メッセージを送信して現在の選択を適用してください。"
+    },
     "session_runtime": {
       "session_busy": "このセッションはまだ前のメッセージを処理しています。しばらくしてからもう一度お試しください。",
       "invocation_conflict": "このメッセージは別の内容で既に送信されています。セッションを再読み込みして保存済みの内容を確認してください。",
 
@@ -230,6 +230,9 @@
       "runtime_busy": "请等待当前回复结束后再切换 Agent 账号。",
       "materialization_failed": "Agent 账号准备失败，请重试。"
     },
+    "session": {
+      "model_preference_conflict": "模型选择已在其他位置更新，请刷新，或发送消息以使用当前选择。"
+    },
     "session_runtime": {
       "session_busy": "这个会话还在处理上一条消息，请稍后再试。",
       "invocation_conflict": "这条消息已用不同内容提交过，请刷新会话查看已保存的内容。",
 
@@ -1,10 +1,28 @@
+// jsdom's localStorage is unavailable under this runner (node shadows it),
+// so the pair-draft tests run against a Map-backed stub, matching the
+// markdown test's precedent.
+const pairDraftStorage = new Map<string, string>()
+Object.defineProperty(globalThis, 'localStorage', {
+  value: {
+    getItem: (k: string) => pairDraftStorage.get(k) ?? null,
+    setItem: (k: string, v: string) => void pairDraftStorage.set(k, String(v)),
+    removeItem: (k: string) => void pairDraftStorage.delete(k),
+    clear: () => pairDraftStorage.clear(),
+  },
+})
 import { describe, expect, it } from 'vitest'
 import {
   captureChatPaneSendContext,
+  carriedPairForSource,
+  clearComposerPairDraft,
   composerHasNoModel,
+  composerPairDraftKey,
   matchesChatPaneSendContext,
   pinnedSubagentModelId,
+  readComposerPairDraft,
   shouldRefreshACPComposerConfig,
+  welcomeSendConsumedDraft,
+  writeComposerPairDraft,
 } from './chat-pane-send'
 
 describe('chat pane send context', () => {
@@ -108,3 +126,45 @@ describe('pinned subagent model', () => {
     expect(pinnedSubagentModelId('subagent', { model_uuid: 'model-gone' }, models)).toBe('')
   })
 })
+
+describe('carried pair gate (issue #879)', () => {
+  it.each([
+    { source: 'user', want: { modelId: 'm-1', reasoningEffort: 'high' } },
+    { source: 'session', want: { modelId: 'm-1', reasoningEffort: 'high' } },
+    { source: 'default', want: { modelId: '', reasoningEffort: '' } },
+    { source: 'unset', want: { modelId: '', reasoningEffort: '' } },
+  ])('source $source carries $want', ({ source, want }) => {
+    expect(carriedPairForSource(source, ' m-1 ', ' high ')).toEqual(want)
+  })
+})
+
+describe('composer pair draft', () => {
+  it('round-trips and clears per bot', () => {
+    writeComposerPairDraft('bot-1', { model_id: 'm-1', reasoning_effort: 'high' })
+    writeComposerPairDraft('bot-2', { model_id: 'm-2', reasoning_effort: 'low' })
+    expect(readComposerPairDraft('bot-1')).toEqual({ model_id: 'm-1', reasoning_effort: 'high' })
+    clearComposerPairDraft('bot-1')
+    expect(readComposerPairDraft('bot-1')).toBeNull()
+    expect(readComposerPairDraft('bot-2')).toEqual({ model_id: 'm-2', reasoning_effort: 'low' })
+  })
+
+  it('treats a model-less payload as no draft', () => {
+    localStorage.setItem(composerPairDraftKey('bot-1'), JSON.stringify({ reasoning_effort: 'high' }))
+    expect(readComposerPairDraft('bot-1')).toBeNull()
+  })
+})
+
+describe('welcome send consumes the draft', () => {
+  it('keeps the draft when a command succeeds without sending a message', () => {
+    expect(welcomeSendConsumedDraft({}, { ok: true })).toBe(false)
+  })
+
+  it('clears only on a successful welcome send', () => {
+    expect(welcomeSendConsumedDraft({ sessionId: '' }, { ok: true, messageSent: true })).toBe(true)
+    expect(welcomeSendConsumedDraft({}, { ok: true, messageSent: true })).toBe(true)
+    // An existing-session send never touches the draft...
+    expect(welcomeSendConsumedDraft({ sessionId: 's-1' }, { ok: true, messageSent: true })).toBe(false)
+    // ...and neither does a failed welcome send (the pick was never persisted).
+    expect(welcomeSendConsumedDraft({ sessionId: '' }, { ok: false })).toBe(false)
+  })
+})
@@ -77,3 +77,70 @@ export function shouldRefreshACPComposerConfig(
     && typeof result.errorCode === 'string'
     && ACP_STALE_CONFIG_CODES.has(result.errorCode)
 }
+
+// ── Composer (model, effort) pair draft (issue #879) ─────────────────────
+// The welcome composer keeps its picked pair in a per-bot localStorage draft
+// until the pair is durably handed to the server. The draft is consumed ONLY
+// by a successful welcome send (REST createSession or the WS first message —
+// both persist the pair with the session); it must survive everything else:
+// opening a historical session, a hard refresh, a failed send (spec P2′).
+
+// carriedPairForSource is the wire gate (spec §3.4): only explicit sources
+// (user pick, remembered session) are carried on send/retry/edit/
+// createSession; default-sourced and unset pairs are omitted so the server
+// can tell "never picked" apart from "picked the default", and the session
+// keeps following the bot default live.
+export function carriedPairForSource(
+  source: string,
+  modelId: string,
+  reasoningEffort: string,
+): { modelId: string, reasoningEffort: string } {
+  if (source !== 'user' && source !== 'session') return { modelId: '', reasoningEffort: '' }
+  return { modelId: modelId.trim(), reasoningEffort: reasoningEffort.trim() }
+}
+
+export function composerPairDraftKey(botId: string): string {
+  return `memoh:composer-pair:${botId.trim()}`
+}
+
+export interface ComposerPairDraft {
+  model_id: string
+  reasoning_effort: string
+}
+
+// All three draft operations swallow storage failures (private mode, quota):
+// the draft is a persistence scaffold, never the state of record.
+export function readComposerPairDraft(botId: string): ComposerPairDraft | null {
+  try {
+    const raw = localStorage.getItem(composerPairDraftKey(botId))
+    if (!raw) return null
+    const parsed = JSON.parse(raw) as { model_id?: string, reasoning_effort?: string }
+    return parsed.model_id ? { model_id: parsed.model_id, reasoning_effort: parsed.reasoning_effort ?? '' } : null
+  } catch {
+    return null
+  }
+}
+
+export function writeComposerPairDraft(botId: string, draft: ComposerPairDraft): void {
+  try {
+    localStorage.setItem(composerPairDraftKey(botId), JSON.stringify(draft))
+  } catch { /* private mode / quota: the draft simply doesn't persist */ }
+}
+
+export function clearComposerPairDraft(botId: string): void {
+  try {
+    localStorage.removeItem(composerPairDraftKey(botId))
+  } catch { /* ignore */ }
+}
+
+// welcomeSendConsumedDraft is the ONLY moment the draft may be cleared: the
+// welcome send succeeded, so the pair now lives server-side. Clearing any
+// earlier — e.g. on a welcome→session repoint — would wipe an unsent pick
+// when the user merely opens a historical session (spec P2′). A failed send
+// keeps the draft: the pick was never persisted.
+export function welcomeSendConsumedDraft(
+  target: { sessionId?: string | null },
+  result: { ok: boolean, messageSent?: boolean },
+): boolean {
+  return result.ok && result.messageSent === true && !(target.sessionId ?? '').trim()
+}