fix: desktop provider kepp TUI

desktop/src-tauri/Cargo.lock

@@ -485,6 +485,7 @@ name = "claude-code-desktop"
 version = "0.2.9"
 dependencies = [
  "anyhow",
+ "dirs 5.0.1",
  "portable-pty",
  "reqwest",
  "serde",
@@ -784,13 +785,34 @@ dependencies = [
  "crypto-common",
 ]
 
+[[package]]
+name = "dirs"
+version = "5.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
+dependencies = [
+ "dirs-sys 0.4.1",
+]
+
 [[package]]
 name = "dirs"
 version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
 dependencies = [
- "dirs-sys",
+ "dirs-sys 0.5.0",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users 0.4.6",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -801,7 +823,7 @@ checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 dependencies = [
  "libc",
  "option-ext",
- "redox_users",
+ "redox_users 0.5.2",
  "windows-sys 0.61.2",
 ]
 
@@ -3199,6 +3221,17 @@ dependencies = [
  "bitflags 2.11.1",
 ]
 
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.5.2"
@@ -4175,7 +4208,7 @@ dependencies = [
  "anyhow",
  "bytes",
  "cookie",
- "dirs",
+ "dirs 6.0.0",
  "dunce",
  "embed_plist",
  "getrandom 0.3.4",
@@ -4225,7 +4258,7 @@ checksum = "4bbc990d1dbf57a8e1c7fa2327f2a614d8b757805603c1b9ba5c81bade09fd4d"
 dependencies = [
  "anyhow",
  "cargo_toml",
- "dirs",
+ "dirs 6.0.0",
  "glob",
  "heck 0.5.0",
  "json-patch",
@@ -4410,7 +4443,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "806d9dac662c2e4594ff03c647a552f2c9bd544e7d0f683ec58f872f952ce4af"
 dependencies = [
  "base64 0.22.1",
- "dirs",
+ "dirs 6.0.0",
  "flate2",
  "futures-util",
  "http",
@@ -4920,7 +4953,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5e85aa143ceb072062fc4d6356c1b520a51d636e7bc8e77ec94be3608e5e80c"
 dependencies = [
  "crossbeam-channel",
- "dirs",
+ "dirs 6.0.0",
  "libappindicator",
  "muda",
  "objc2",
@@ -5577,6 +5610,15 @@ dependencies = [
  "windows-targets 0.42.2",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -5628,6 +5670,21 @@ dependencies = [
  "windows_x86_64_msvc 0.42.2",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -5685,6 +5742,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -5703,6 +5766,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -5721,6 +5790,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -5751,6 +5826,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -5769,6 +5850,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -5787,6 +5874,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -5805,6 +5898,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
@@ -5970,7 +6069,7 @@ dependencies = [
  "block2",
  "cookie",
  "crossbeam-channel",
- "dirs",
+ "dirs 6.0.0",
  "dom_query",
  "dpi",
  "dunce",

desktop/src-tauri/Cargo.toml

@@ -25,3 +25,4 @@ portable-pty = "0.9.0"
 tauri-plugin-notification = "2"
 tauri-plugin-single-instance = "2"
 reqwest = { version = "0.13", default-features = false, features = ["system-proxy"] }
+dirs = "5"

desktop/src-tauri/src/lib.rs

@@ -1151,6 +1151,78 @@ fn set_app_zoom(window: tauri::WebviewWindow, zoom_factor: f64) -> Result<(), St
         .map_err(|err| format!("set app zoom: {err}"))
 }
 
+/// Get the path to ~/.claude.json (mirrors TUI's getGlobalClaudeFile)
+fn get_global_claude_file_path() -> std::path::PathBuf {
+    // Same logic as TUI's getGlobalClaudeFile(): follow CLAUDE_CONFIG_DIR, then homedir
+    if let Ok(config_dir) = std::env::var("CLAUDE_CONFIG_DIR") {
+        std::path::PathBuf::from(config_dir).join(".claude.json")
+    } else {
+        dirs::home_dir()
+            .map(|h| h.join(".claude.json"))
+            .unwrap_or_else(|| std::path::PathBuf::from(".claude.json"))
+    }
+}
+
+/// Read the global Claude config file (~/.claude.json).
+/// Returns the parsed JSON or null if the file doesn't exist.
+#[tauri::command]
+fn get_claude_config() -> Result<serde_json::Value, String> {
+    let path = get_global_claude_file_path();
+    match fs::read_to_string(&path) {
+        Ok(content) => serde_json::from_str(&content)
+            .map_err(|e| format!("parse {}: {e}", path.display())),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(serde_json::Value::Null),
+        Err(e) => Err(format!("read {}: {e}", path.display())),
+    }
+}
+
+/// Write the global Claude config file (~/.claude.json).
+/// The content is merged with the existing file (deep merge).
+#[tauri::command]
+fn save_claude_config(patch: serde_json::Value) -> Result<(), String> {
+    let path = get_global_claude_file_path();
+    // Ensure parent directory exists
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|e| format!("create config dir {}: {e}", parent.display()))?;
+    }
+    // Read existing content
+    let existing: serde_json::Value = if path.exists() {
+        let content = fs::read_to_string(&path)
+            .map_err(|e| format!("read {}: {e}", path.display()))?;
+        serde_json::from_str(&content)
+            .unwrap_or(serde_json::Value::Object(serde_json::Map::new()))
+    } else {
+        serde_json::Value::Object(serde_json::Map::new())
+    };
+    // Deep merge: patch overrides existing
+    let merged = deep_merge_json(&existing, &patch);
+    let json = serde_json::to_string_pretty(&merged)
+        .map_err(|e| format!("serialize config: {e}"))?;
+    fs::write(&path, json)
+        .map_err(|e| format!("write {}: {e}", path.display()))?;
+    Ok(())
+}
+
+/// Deep-merge two JSON objects. Patch values override existing ones.
+/// Arrays are replaced, not concatenated.
+fn deep_merge_json(base: &serde_json::Value, patch: &serde_json::Value) -> serde_json::Value {
+    match (base, patch) {
+        (serde_json::Value::Object(base_map), serde_json::Value::Object(patch_map)) => {
+            let mut result = base_map.clone();
+            for (key, patch_val) in patch_map {
+                let merged = match result.get(key) {
+                    Some(existing_val) => deep_merge_json(existing_val, patch_val),
+                    None => patch_val.clone(),
+                };
+                result.insert(key.clone(), merged);
+            }
+            serde_json::Value::Object(result)
+        }
+        _ => patch.clone(),
+    }
+}
+
 #[cfg(target_os = "windows")]
 fn open_windows_notification_settings_impl() -> Result<bool, String> {
     StdCommand::new("explorer.exe")
@@ -2129,7 +2201,9 @@ pub fn run() {
             get_app_mode,
             set_app_mode,
             detect_portable_dir,
-            set_app_zoom
+            set_app_zoom,
+            get_claude_config,
+            save_claude_config
         ]);
 
     // macOS: native menu bar (traffic-light overlay style)

desktop/src-tauri/tauri.conf.json

@@ -24,7 +24,7 @@
     ],
     "security": {
       "dangerousDisableAssetCspModification": ["style-src"],
-      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: asset: https://asset.localhost http://127.0.0.1:* http://localhost:*; font-src 'self' data:; connect-src 'self' ws://127.0.0.1:* http://127.0.0.1:* ws://localhost:* http://localhost:*; media-src 'self' blob:"
+      "csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: asset: https://asset.localhost http://127.0.0.1:* http://localhost:*; font-src 'self' data:; connect-src 'self' https: ws://127.0.0.1:* http://127.0.0.1:* ws://localhost:* http://localhost:*; media-src 'self' blob:"
     }
   },
   "plugins": {

desktop/src/api/config.ts

@@ -0,0 +1,91 @@
+/**
+ * TUI-style configuration reading layer for desktop.
+ *
+ * Mirrors TUI's src/utils/config.ts and src/utils/env.ts reading patterns,
+ * using Rust Tauri commands to read ~/.claude.json directly instead of going
+ * through the cc-haha sidecar HTTP API.
+ *
+ * This allows the desktop app to use the same configuration files as the TUI,
+ * making cc-haha's /api/cli-auth endpoint unnecessary for config reads.
+ */
+
+import { invoke } from '@tauri-apps/api/core'
+
+// Re-export types that mirror TUI's GlobalConfig shape
+export type TuiGlobalConfig = {
+  // Auth provider
+  authProvider?: 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | 'nvidia' | null
+
+  // API Keys
+  primaryApiKey?: string
+  openAiApiKey?: string
+  openAiAccessToken?: string
+  openRouterApiKey?: string
+  nvidiaApiKey?: string
+  openCodeApiKey?: string
+  openCodeModelName?: string
+  localBaseUrl?: string
+  localModelName?: string
+
+  // OAuth
+  oauthAccount?: {
+    emailAddress?: string
+    organizationName?: string
+    uuid?: string
+  }
+
+  // Model selection
+  model?: string
+  effortLevel?: string
+
+  // Other fields we don't actively use but preserve
+  [key: string]: unknown
+}
+
+let configCache: TuiGlobalConfig | null = null
+let configCacheTime = 0
+const CONFIG_CACHE_TTL = 2000 // 2 seconds — balance freshness vs perf
+
+/**
+ * Get the global Claude config (~/.claude.json) from the Rust layer.
+ * Results are cached for CONFIG_CACHE_TTL ms to avoid excessive Rust IPC calls.
+ */
+export async function getTuiConfig(): Promise<TuiGlobalConfig> {
+  const now = Date.now()
+  if (configCache !== null && now - configCacheTime < CONFIG_CACHE_TTL) {
+    return configCache
+  }
+
+  try {
+    const result = await invoke<unknown>('get_claude_config')
+    if (result === null) {
+      configCache = {}
+    } else {
+      configCache = result as TuiGlobalConfig
+    }
+    configCacheTime = now
+    return configCache!
+  } catch (err) {
+    console.error('[config] failed to read ~/.claude.json:', err)
+    return {}
+  }
+}
+
+/**
+ * Save a partial patch to ~/.claude.json (deep-merged with existing content).
+ */
+export async function saveTuiConfigPatch(patch: Partial<TuiGlobalConfig>): Promise<void> {
+  await invoke('save_claude_config', { patch })
+  // Invalidate cache so next read picks up the change
+  configCache = null
+  configCacheTime = 0
+}
+
+/**
+ * Clear the in-memory config cache.
+ * Call this after making config changes to force a fresh read.
+ */
+export function clearConfigCache(): void {
+  configCache = null
+  configCacheTime = 0
+}

desktop/src/api/providerModels.ts

@@ -0,0 +1,228 @@
+/**
+ * Direct provider model fetcher.
+ *
+ * Fetches available models directly from provider APIs, mirroring the logic
+ * in TUI's openRouterModels.ts / nvidiaClient.ts / opencodeClient.ts.
+ *
+ * This bypasses the cc-haha sidecar's /api/models endpoint entirely,
+ * reusing TUI's model acquisition approach in the desktop WebView.
+ */
+
+import { getTuiConfig } from './config'
+import type { ModelInfo } from '../types/settings'
+
+// ─── Type ────────────────────────────────────────────────────────────────────
+
+type FetchResult = {
+  models: ModelInfo[]
+  provider: { id: string; name: string } | null
+}
+
+// ─── Cache ───────────────────────────────────────────────────────────────────
+
+let modelCache: { key: string; models: ModelInfo[] } | null = null
+let cacheTime = 0
+const CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+export function clearProviderModelCache(): void {
+  modelCache = null
+  cacheTime = 0
+}
+
+// ─── Main entry ──────────────────────────────────────────────────────────────
+
+export async function fetchProviderModels(): Promise<FetchResult> {
+  const config = await getTuiConfig()
+  const authProvider = (config.authProvider as string | undefined) || null
+
+  const cacheKey = authProvider ?? '__default__'
+  if (modelCache && modelCache.key === cacheKey && Date.now() - cacheTime < CACHE_TTL) {
+    return { models: modelCache.models, provider: null }
+  }
+
+  let models: ModelInfo[] = []
+  let providerInfo: { id: string; name: string } | null = null
+
+  switch (authProvider) {
+    case 'openrouter': {
+      const apiKey = config.openRouterApiKey as string | undefined
+      models = await fetchOpenRouterModels(apiKey)
+      providerInfo = models.length > 0
+        ? { id: 'cli-openrouter', name: 'OpenRouter' }
+        : null
+      break
+    }
+
+    case 'nvidia': {
+      const apiKey = config.nvidiaApiKey as string | undefined
+      const baseUrl = config.nvidiaBaseUrl as string | undefined
+      models = await fetchNvidiaModels(apiKey, baseUrl || 'https://integrate.api.nvidia.com/v1')
+      providerInfo = models.length > 0
+        ? { id: 'cli-nvidia', name: 'NVIDIA' }
+        : null
+      break
+    }
+
+    case 'opencode': {
+      models = await fetchOpencodeModels()
+      providerInfo = models.length > 0
+        ? { id: 'cli-opencode', name: 'OpenCode Zen' }
+        : null
+      break
+    }
+
+    case 'openai':
+      // OpenAI models are best fetched via the official provider API.
+      // For now, the static catalog from modelCatalog.ts is used.
+      break
+
+    case 'local': {
+      const modelName = config.localModelName as string | undefined
+      if (modelName) {
+        models = [{ id: modelName, name: modelName, description: 'Local model', context: '' }]
+      }
+      providerInfo = { id: 'cli-local', name: 'Local' }
+      break
+    }
+
+    default:
+      // firstParty / anthropic — no external fetch, use static defaults
+      break
+  }
+
+  modelCache = { key: cacheKey, models }
+  cacheTime = Date.now()
+
+  return { models, provider: providerInfo }
+}
+
+// ─── OpenRouter ──────────────────────────────────────────────────────────────
+
+let orCache: ModelInfo[] | null = null
+let orCacheTime = 0
+const OR_CACHE_TTL = 5 * 60 * 1000
+
+async function fetchOpenRouterModels(apiKey?: string | null): Promise<ModelInfo[]> {
+  if (orCache && Date.now() - orCacheTime < OR_CACHE_TTL) {
+    return orCache
+  }
+
+  if (!apiKey) {
+    orCache = []
+    orCacheTime = Date.now()
+    return []
+  }
+
+  try {
+    const res = await fetch('https://openrouter.ai/api/v1/models', {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(20_000),
+    })
+    if (!res.ok) {
+      orCache = []
+      return []
+    }
+
+    const data = (await res.json()) as { data?: Array<{ id: string; name: string; description?: string; context_length?: number }> }
+    const models: ModelInfo[] = (data.data || [])
+      .filter((m) => {
+        const id = m.id.toLowerCase()
+        return id.includes('/') && !id.startsWith('router') && !id.startsWith('free') && !id.startsWith('aggregat')
+      })
+      .map((m) => ({
+        id: m.id,
+        name: m.name || m.id,
+        description: (m.description || '').length > 100 ? m.description!.slice(0, 97) + '...' : (m.description || ''),
+        context: String(m.context_length || ''),
+      }))
+
+    orCache = models
+    orCacheTime = Date.now()
+    return models
+  } catch {
+    orCache = orCache || []
+    return orCache
+  }
+}
+
+// ─── NVIDIA NIM ──────────────────────────────────────────────────────────────
+
+let nvCache: ModelInfo[] | null = null
+let nvCacheTime = 0
+
+async function fetchNvidiaModels(apiKey?: string | null, baseUrl?: string): Promise<ModelInfo[]> {
+  if (nvCache && Date.now() - nvCacheTime < OR_CACHE_TTL) {
+    return nvCache
+  }
+
+  if (!apiKey) {
+    nvCache = []
+    nvCacheTime = Date.now()
+    return []
+  }
+
+  const normalized = (baseUrl || 'https://integrate.api.nvidia.com/v1').replace(/\/$/, '')
+  const modelsUrl = normalized.endsWith('/v1') ? `${normalized}/models` : `${normalized}/v1/models`
+
+  try {
+    const res = await fetch(modelsUrl, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(20_000),
+    })
+    if (!res.ok) {
+      nvCache = []
+      return []
+    }
+
+    const json = (await res.json()) as { data?: Array<{ id: string }> }
+    if (json.data && Array.isArray(json.data)) {
+      const models: ModelInfo[] = json.data.map((m) => ({
+        id: m.id,
+        name: m.id,
+        description: 'NVIDIA NIM model',
+        context: '',
+      }))
+      nvCache = models
+      nvCacheTime = Date.now()
+      return models
+    }
+
+    nvCache = []
+    return []
+  } catch {
+    nvCache = nvCache || []
+    return nvCache
+  }
+}
+
+// ─── OpenCode Zen ────────────────────────────────────────────────────────────
+
+export async function fetchOpencodeModels(): Promise<ModelInfo[]> {
+  try {
+    const res = await fetch('https://models.dev/api.json', {
+      signal: AbortSignal.timeout(15_000),
+    })
+    if (!res.ok) return []
+
+    const data = (await res.json()) as {
+      opencode?: { models?: Record<string, { name?: string; status?: string; cost?: { input?: number; output?: number } }> }
+    }
+    const opencodeModels = data?.opencode?.models || {}
+    const models: ModelInfo[] = []
+
+    for (const [modelId, cfg] of Object.entries(opencodeModels)) {
+      if (cfg.status === 'deprecated') continue
+      const isFree = cfg.cost?.input === 0 && cfg.cost?.output === 0
+      models.push({
+        id: modelId,
+        name: cfg.name || modelId,
+        description: isFree ? 'Free model' : 'Paid model',
+        context: '',
+      })
+    }
+
+    return models
+  } catch {
+    return []
+  }
+}

desktop/src/lib/modelOptions.ts

@@ -0,0 +1,208 @@
+/**
+ * Desktop model options utility.
+ *
+ * Mirrors key logic from TUI's src/utils/model/modelOptions.ts
+ * but adapted for the desktop React context.
+ *
+ * Core value: provider-tier-aware model filtering (Max gets Opus,
+ * Pro gets Sonnet, etc.) and environment-variable overrides that
+ * TUI supports but the cc-haha /api/models endpoint doesn't expose.
+ */
+
+import type { ModelInfo } from '../types/settings'
+
+export type ModelOption = {
+  value: string | null  // null = default
+  label: string
+  description: string
+  descriptionForModel?: string
+}
+
+/** Determine the effective auth provider from ~/.claude.json config. */
+export async function getConfigAuthProvider(): Promise<string | null> {
+  const { invoke } = await import('@tauri-apps/api/core')
+  try {
+    const config = await invoke<Record<string, unknown>>('get_claude_config')
+    return (config?.authProvider as string | null) ?? null
+  } catch {
+    return null
+  }
+}
+
+// Provider-specific model strings (simplified from TUI's modelStrings.ts)
+// Desktop uses these for display labels when the full TUI module isn't loaded.
+export const DESKTOP_MODEL_STRINGS = {
+  opus46: 'claude-opus-4-6-20250514',
+  sonnet46: 'claude-sonnet-4-6-20250608',
+  haiku45: 'claude-haiku-4-5-20250522',
+  opus45: 'claude-opus-4-5-20241022',
+  sonnet45: 'claude-sonnet-4-5-20241022',
+  haiku35: 'claude-haiku-3-5-20241022',
+} as const
+
+/**
+ * Build ModelOption[] for a given provider and subscription tier.
+ * This mirrors the logic in TUI's getModelOptions() but without the
+ * full TUI bootstrap/graphbook dependency tree.
+ *
+ * @param provider - The active API provider from config
+ * @param isSubscriber - Whether the user has a claude.ai subscription
+ * @param subscriptionType - 'max' | 'pro' | 'team' | null
+ * @param fastMode - Whether fast mode is enabled
+ * @param availableModels - Existing model list from cc-haha (supplemental)
+ */
+export function buildModelOptions(
+  provider: string | null,
+  _isSubscriber: boolean,
+  subscriptionType: string | null,
+  fastMode: boolean,
+  availableModels: ModelInfo[],
+): ModelOption[] {
+  const opts: ModelOption[] = []
+
+  // Default always first
+  opts.push({
+    value: null,
+    label: 'Default (recommended)',
+    description: getDefaultDescription(subscriptionType),
+  })
+
+  if (!provider) {
+    return opts
+  }
+
+  const is3P = provider !== 'firstParty'
+
+  switch (provider) {
+    case 'firstParty': {
+      // Sonnet 4.6 is default for PAYG / non-subscriber
+      opts.push(makeSonnet46(is3P))
+      // Sonnet 1M if available
+      opts.push(makeSonnet46_1M(is3P))
+      // Opus 4.6 alternatives
+      if (isOpus1mMergeEnabled(_isSubscriber, subscriptionType)) {
+        opts.push(makeOpus46_1M(fastMode, is3P))
+      } else {
+        opts.push(makeOpus46(fastMode, is3P))
+      }
+      // Haiku
+      opts.push(makeHaiku45(is3P))
+      break
+    }
+
+    case 'openai': {
+      // Map to GPT models for display
+      opts.push({ value: 'gpt-5.4', label: 'GPT-5.4', description: 'GPT-5.4 · Recommended for most coding tasks' })
+      opts.push({ value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini', description: 'GPT-5.4 Mini · Fastest OpenAI option' })
+      break
+    }
+
+    case 'opencode': {
+      // OpenCode models - use available list or fall back to defaults
+      if (availableModels.length > 0) {
+        for (const m of availableModels) {
+          opts.push({ value: m.id, label: m.name || m.id, description: m.description || 'OpenCode model' })
+        }
+      } else {
+        // Fallback defaults from DESKTOP_MODEL_STRINGS
+        opts.push({ value: 'big-pickle', label: 'Big Pickle', description: '旗舰模型，限时免费，适合复杂任务' })
+        opts.push({ value: 'gpt-5-nano', label: 'GPT 5 Nano', description: '永久免费，轻量快速，隐私安全' })
+      }
+      break
+    }
+
+    case 'nvidia': {
+      if (availableModels.length > 0) {
+        for (const m of availableModels) {
+          opts.push({ value: m.id, label: m.name || m.id, description: m.description || 'NVIDIA NIM model' })
+        }
+      }
+      break
+    }
+
+    case 'local': {
+      // Local models come from availableModels
+      for (const m of availableModels) {
+        opts.push({ value: m.id, label: m.name || m.id, description: m.description || 'Local model' })
+      }
+      break
+    }
+
+    case 'openrouter': {
+      if (availableModels.length > 0) {
+        for (const m of availableModels) {
+          opts.push({ value: m.id, label: m.name || m.id, description: m.description || 'OpenRouter model' })
+        }
+      }
+      break
+    }
+
+    default:
+      // For unknown providers, supplement with availableModels
+      for (const m of availableModels) {
+        opts.push({ value: m.id, label: m.name || m.id, description: m.description || 'Model' })
+      }
+      break
+  }
+
+  return opts
+}
+
+function getDefaultDescription(subscriptionType: string | null): string {
+  if (subscriptionType === 'max') return 'Opus 4.6 · Most capable for complex work'
+  if (subscriptionType === 'pro') return 'Sonnet 4.6 · Best for everyday tasks'
+  return 'Sonnet 4.6 · Best for everyday tasks'
+}
+
+function isOpus1mMergeEnabled(_isSubscriber: boolean, subscriptionType: string | null): boolean {
+  // Only enable 1M for Max/Team Premium subscribers on firstParty
+  if (subscriptionType === 'max' || subscriptionType === 'team') return true
+  return false
+}
+
+function makeSonnet46(is3P: boolean): ModelOption {
+  return {
+    value: 'sonnet',
+    label: 'Sonnet',
+    description: `Sonnet 4.6 · Best for everyday tasks${is3P ? '' : ' · $3 / M input, $15 / M output'}`,
+    descriptionForModel: 'Sonnet 4.6 - best for everyday tasks',
+  }
+}
+
+function makeSonnet46_1M(is3P: boolean): ModelOption {
+  return {
+    value: 'sonnet[1m]',
+    label: 'Sonnet (1M context)',
+    description: `Sonnet 4.6 with 1M context window${is3P ? '' : ' · $3 / M input, $15 / M output'}`,
+    descriptionForModel: 'Sonnet 4.6 with 1M context window - for long sessions',
+  }
+}
+
+function makeOpus46(fastMode: boolean, is3P: boolean): ModelOption {
+  const suffix = fastMode && !is3P ? ' · ⚡ $7.50 / M input, $37.50 / M output' : ''
+  return {
+    value: 'opus',
+    label: 'Opus',
+    description: `Opus 4.6 · Most capable for complex work${suffix}`,
+    descriptionForModel: 'Opus 4.6 - most capable for complex work',
+  }
+}
+
+function makeOpus46_1M(fastMode: boolean, is3P: boolean): ModelOption {
+  const suffix = fastMode && !is3P ? ' · ⚡ $7.50 / M input, $37.50 / M output' : ''
+  return {
+    value: 'opus[1m]',
+    label: 'Opus (1M context)',
+    description: `Opus 4.6 with 1M context${suffix}`,
+    descriptionForModel: 'Opus 4.6 with 1M context - most capable for complex work',
+  }
+}
+
+function makeHaiku45(is3P: boolean): ModelOption {
+  return {
+    value: 'haiku',
+    label: 'Haiku',
+    description: `Haiku 4.5 · Fastest for quick answers${is3P ? '' : ' · $0.08 / M input, $0.40 / M output'}`,
+    descriptionForModel: 'Haiku 4.5 - fastest for quick answers',
+  }
+}

desktop/src/lib/tuiConversation.ts

@@ -0,0 +1,434 @@
+/**
+ * TUI-style conversation module for desktop.
+ *
+ * Reuses TUI's approach of directly calling provider APIs via HTTP,
+ * without going through the cc-haha sidecar or CLI subprocess.
+ *
+ * Supports all provider types:
+ *  - Anthropic protocol: firstParty, openrouter, openai, local
+ *  - OpenAI protocol: nvidia (NIM), opencode
+ *
+ * Config is read from ~/.claude.json via getTuiConfig().
+ */
+
+import { getTuiConfig } from '../api/config'
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export type ConversationMessage = {
+  role: 'user' | 'assistant'
+  content: string
+}
+
+export type ConversationStreamEvent =
+  | { type: 'text_delta'; text: string }
+  | { type: 'thinking_delta'; thinking: string }
+  | { type: 'content_block_start'; index: number; blockType: string }
+  | { type: 'content_block_stop'; index: number }
+  | { type: 'message_stop'; usage?: { input_tokens?: number; output_tokens?: number } }
+  | { type: 'error'; message: string }
+  | { type: 'done' }
+
+export type ConversationResult = {
+  content: string
+  usage?: { input_tokens: number; output_tokens: number }
+}
+
+// ─── Provider client factory ────────────────────────────────────────────────
+
+type ProviderClientConfig = {
+  baseUrl: string
+  apiKey: string
+  model: string
+  /** Anthropic Messages API vs OpenAI Chat Completions */
+  protocol: 'anthropic' | 'openai'
+}
+
+async function resolveProviderConfig(model?: string): Promise<ProviderClientConfig> {
+  const config = await getTuiConfig()
+  const authProvider = (config.authProvider as string) || 'anthropic'
+
+  // Resolve API key and base URL based on provider
+  switch (authProvider) {
+    case 'openrouter': {
+      const apiKey = config.openRouterApiKey as string
+      if (!apiKey) throw new Error('OpenRouter API key not configured. Run /login first.')
+      return {
+        baseUrl: (process.env as Record<string, string>).OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1',
+        apiKey,
+        model: model || 'anthropic/claude-sonnet-4-6',
+        protocol: 'anthropic',
+      }
+    }
+
+    case 'nvidia': {
+      const apiKey = config.nvidiaApiKey as string
+      if (!apiKey) throw new Error('NVIDIA NIM API key not configured. Run /login first.')
+      const nvidiaBaseUrl = (config.nvidiaBaseUrl as string) || 'https://integrate.api.nvidia.com/v1'
+      return {
+        baseUrl: nvidiaBaseUrl,
+        apiKey,
+        model: model || (config.nvidiaModel as string) || 'nvidia/llama-3.1-nemotron-70b-instruct',
+        protocol: 'openai',
+      }
+    }
+
+    case 'opencode': {
+      const apiKey = config.openCodeApiKey as string
+      return {
+        baseUrl: 'https://opencode.ai/zen/v1',
+        apiKey: apiKey || 'public',
+        model: model || (config.openCodeModelName as string) || 'big-pickle',
+        protocol: 'openai',
+      }
+    }
+
+    case 'openai': {
+      const apiKey = (config.openAiApiKey as string) || (config.openAiAccessToken as string)
+      if (!apiKey) throw new Error('OpenAI API key not configured.')
+      return {
+        baseUrl: (process.env as Record<string, string>).OPENAI_BASE_URL || 'https://api.openai.com/v1',
+        apiKey,
+        model: model || 'gpt-5.4-codex',
+        protocol: 'openai',
+      }
+    }
+
+    case 'local': {
+      const localBaseUrl = config.localBaseUrl as string
+      if (!localBaseUrl) throw new Error('Local provider base URL not configured.')
+      return {
+        baseUrl: localBaseUrl,
+        apiKey: 'local-model',
+        model: model || (config.localModelName as string) || 'local-model',
+        protocol: 'openai', // Most local providers use OpenAI-compatible API
+      }
+    }
+
+    default: {
+      // First-party Anthropic
+      const apiKey = config.anthropicApiKey as string
+      if (!apiKey) throw new Error('Anthropic API key not configured.')
+      return {
+        baseUrl: (process.env as Record<string, string>).ANTHROPIC_BASE_URL || 'https://api.anthropic.com/v1',
+        apiKey,
+        model: model || 'claude-sonnet-4-6',
+        protocol: 'anthropic',
+      }
+    }
+  }
+}
+
+// ─── HTTP helpers ────────────────────────────────────────────────────────────
+
+function anthropicHeaders(apiKey: string): Record<string, string> {
+  return {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': '2023-06-01',
+    'User-Agent': 'versperclaw-desktop/1.0',
+  }
+}
+
+function openaiHeaders(apiKey: string): Record<string, string> {
+  return {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${apiKey}`,
+    'User-Agent': 'versperclaw-desktop/1.0',
+  }
+}
+
+// ─── OpenAI protocol streaming ───────────────────────────────────────────────
+
+async function* streamOpenAI(
+  config: ProviderClientConfig,
+  messages: ConversationMessage[],
+  signal?: AbortSignal,
+): AsyncGenerator<ConversationStreamEvent> {
+  const body = {
+    model: config.model,
+    messages: messages.map(m => ({ role: m.role, content: m.content })),
+    stream: true,
+  }
+
+  let res: Response
+  try {
+    res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/chat/completions`, {
+      method: 'POST',
+      headers: openaiHeaders(config.apiKey),
+      body: JSON.stringify(body),
+      signal,
+    })
+  } catch (err) {
+    const name = err instanceof TypeError ? err.name : ''
+    const msg = err instanceof Error ? err.message : String(err)
+    console.error('[tuiConversation] OpenAI fetch failed:', { name, message: msg, url: config.baseUrl, model: config.model })
+    yield { type: 'error', message: `Network error: ${msg}${name ? ` (${name})` : ''}` }
+    yield { type: 'done' }
+    return
+  }
+
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '')
+    yield { type: 'error', message: `API error ${res.status}: ${errBody}` }
+    yield { type: 'done' }
+    return
+  }
+
+  if (!res.body) {
+    yield { type: 'error', message: 'No response body' }
+    yield { type: 'done' }
+    return
+  }
+
+  const decoder = new TextDecoder()
+  const reader = res.body.getReader()
+  let buffer = ''
+
+  yield { type: 'content_block_start', index: 0, blockType: 'text' }
+
+  while (true) {
+    if (signal?.aborted) break
+    const { done, value } = await reader.read()
+    if (done) break
+
+    buffer += decoder.decode(value, { stream: true })
+    const lines = buffer.split('\n')
+    buffer = lines.pop() || ''
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue
+      const raw = line.slice(6).trim()
+      if (raw === '[DONE]') {
+        yield { type: 'content_block_stop', index: 0 }
+        yield { type: 'done' }
+        return
+      }
+
+      try {
+        const chunk = JSON.parse(raw)
+        const delta = chunk.choices?.[0]?.delta
+        if (!delta) continue
+
+        if (delta.content) {
+          yield { type: 'text_delta', text: delta.content }
+        }
+        if (delta.reasoning_content) {
+          yield { type: 'thinking_delta', thinking: delta.reasoning_content }
+        }
+      } catch {
+        // Skip malformed JSON
+      }
+    }
+  }
+
+  yield { type: 'content_block_stop', index: 0 }
+  yield { type: 'message_stop' }
+  yield { type: 'done' }
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Send a conversation message and stream the response.
+ * Works for all provider types, bypassing the cc-haha sidecar.
+ *
+ * Usage:
+ * ```ts
+ * for await (const event of sendMessage([...messages])) {
+ *   if (event.type === 'text_delta') { updateUI(event.text) }
+ *   if (event.type === 'done') { break }
+ * }
+ * ```
+ */
+export async function* sendMessage(
+  messages: ConversationMessage[],
+  options?: {
+    model?: string
+    system?: string
+    signal?: AbortSignal
+  },
+): AsyncGenerator<ConversationStreamEvent> {
+  const config = await resolveProviderConfig(options?.model)
+
+  if (config.protocol === 'anthropic') {
+    // Re-implement Anthropic streaming inline with proper yield support
+    const body: Record<string, unknown> = {
+      model: config.model,
+      messages,
+      max_tokens: 4096,
+      stream: true,
+    }
+    if (options?.system) body.system = options.system
+
+    let res: Response
+    try {
+      res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/messages`, {
+        method: 'POST',
+        headers: anthropicHeaders(config.apiKey),
+        body: JSON.stringify(body),
+        signal: options?.signal,
+      })
+    } catch (err) {
+      const name = err instanceof TypeError ? err.name : ''
+      const msg = err instanceof Error ? err.message : String(err)
+      console.error('[tuiConversation] Anthropic fetch failed:', { name, message: msg, url: config.baseUrl, model: config.model })
+      yield { type: 'error', message: `Network error: ${msg}${name ? ` (${name})` : ''}` }
+      yield { type: 'done' }
+      return
+    }
+
+    if (!res.ok) {
+      const errBody = await res.text().catch(() => '')
+      yield { type: 'error', message: `API error ${res.status}: ${errBody}` }
+      yield { type: 'done' }
+      return
+    }
+
+    if (!res.body) {
+      yield { type: 'error', message: 'No response body' }
+      yield { type: 'done' }
+      return
+    }
+
+    const decoder = new TextDecoder()
+    const reader = res.body.getReader()
+    let buffer = ''
+    let usage: { input_tokens?: number; output_tokens?: number } | undefined
+
+    try {
+      while (true) {
+        if (options?.signal?.aborted) break
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const raw = line.slice(6).trim()
+            if (!raw) continue
+
+            try {
+              const data = JSON.parse(raw)
+
+              if (data.type === 'content_block_start') {
+                yield {
+                  type: 'content_block_start',
+                  index: data.index ?? 0,
+                  blockType: data.content_block?.type ?? 'text',
+                }
+              } else if (data.type === 'content_block_delta') {
+                const delta = data.delta
+                if (delta?.type === 'text_delta' && delta.text) {
+                  yield { type: 'text_delta', text: delta.text }
+                } else if (delta?.type === 'thinking_delta' && delta.thinking) {
+                  yield { type: 'thinking_delta', thinking: delta.thinking }
+                }
+              } else if (data.type === 'content_block_stop') {
+                yield { type: 'content_block_stop', index: data.index ?? 0 }
+              } else if (data.type === 'message_start' && data.message?.usage) {
+                usage = data.message.usage
+              } else if (data.type === 'message_delta' && data.delta?.stop_reason) {
+                if (data.usage) usage = data.usage
+              } else if (data.type === 'message_stop') {
+                yield { type: 'message_stop', usage }
+                yield { type: 'done' }
+                return
+              }
+            } catch {
+              // Skip malformed JSON
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock()
+    }
+
+    if (!options?.signal?.aborted) {
+      yield { type: 'message_stop', usage }
+      yield { type: 'done' }
+    }
+  } else {
+    // OpenAI protocol
+    yield* streamOpenAI(config, messages, options?.signal)
+  }
+}
+
+/**
+ * Non-streaming send - returns the complete result.
+ */
+export async function sendMessageSync(
+  messages: ConversationMessage[],
+  options?: {
+    model?: string
+    system?: string
+    signal?: AbortSignal
+  },
+): Promise<ConversationResult> {
+  const config = await resolveProviderConfig(options?.model)
+
+  if (config.protocol === 'anthropic') {
+    const body: Record<string, unknown> = {
+      model: config.model,
+      messages,
+      max_tokens: 4096,
+    }
+    if (options?.system) body.system = options.system
+
+    const res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/messages`, {
+      method: 'POST',
+      headers: anthropicHeaders(config.apiKey),
+      body: JSON.stringify(body),
+      signal: options?.signal,
+    })
+
+    if (!res.ok) {
+      const errBody = await res.text().catch(() => '')
+      throw new Error(`API error ${res.status}: ${errBody}`)
+    }
+
+    const data = (await res.json()) as {
+      content: Array<{ type: string; text?: string }>
+      usage?: { input_tokens: number; output_tokens: number }
+    }
+
+    const text = data.content
+      ?.filter((b) => b.type === 'text')
+      .map((b) => b.text)
+      .join('\n') ?? ''
+
+    return { content: text, usage: data.usage }
+  }
+
+  // OpenAI protocol
+  const body = {
+    model: config.model,
+    messages: messages.map(m => ({ role: m.role, content: m.content })),
+  }
+
+  const res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/chat/completions`, {
+    method: 'POST',
+    headers: openaiHeaders(config.apiKey),
+    body: JSON.stringify(body),
+    signal: options?.signal,
+  })
+
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '')
+    throw new Error(`API error ${res.status}: ${errBody}`)
+  }
+
+  const data = (await res.json()) as {
+    choices: Array<{ message: { content: string | null } }>
+    usage?: { prompt_tokens: number; completion_tokens: number }
+  }
+
+  return {
+    content: data.choices?.[0]?.message?.content ?? '',
+    usage: data.usage ? { input_tokens: data.usage.prompt_tokens, output_tokens: data.usage.completion_tokens } : undefined,
+  }
+}

desktop/src/stores/chatStore.ts

@@ -9,6 +9,8 @@ import { useTabStore } from './tabStore'
 import { randomSpinnerVerb } from '../config/spinnerVerbs'
 import { notifyDesktop } from '../lib/desktopNotifications'
 import { deriveSessionTitle, isPlaceholderSessionTitle } from '../lib/sessionTitle'
+import * as tuiConversation from '../lib/tuiConversation'
+import type { ConversationMessage } from '../lib/tuiConversation'
 import { AGENT_LIFECYCLE_TYPES } from '../types/team'
 import type { ComposerAttachment } from '../lib/composerAttachments'
 import type { MessageEntry } from '../types/session'
@@ -145,6 +147,7 @@ type ChatStore = {
   clearComposerDraft: (sessionId: string) => void
   clearMessages: (sessionId: string) => void
   handleServerMessage: (sessionId: string, msg: ServerMessage) => void
+  startDirectConversation: (sessionId: string, content: string) => Promise<void>
 }
 
 const TASK_TOOL_NAMES = new Set(['TaskCreate', 'TaskUpdate', 'TaskGet', 'TaskList', 'TodoWrite'])
@@ -612,6 +615,21 @@ function mergeSlashCommandUpdates(
   return [...merged.values()]
 }
 
+function buildConversationHistory(messages: UIMessage[]): ConversationMessage[] {
+  const history: ConversationMessage[] = []
+  for (const msg of messages) {
+    if (msg.type === 'user_text') {
+      const record = msg as Extract<UIMessage, { type: 'user_text' }>
+      const text = (record as { modelContent?: string }).modelContent || record.content
+      history.push({ role: 'user', content: text })
+    } else if (msg.type === 'assistant_text') {
+      const text = (msg as Extract<UIMessage, { type: 'assistant_text' }>).content
+      history.push({ role: 'assistant', content: text })
+    }
+  }
+  return history
+}
+
 async function fetchAndMapSessionHistory(sessionId: string) {
   const { messages, taskNotifications } = await sessionsApi.getMessages(sessionId)
   const uiMessages = mapHistoryMessagesToUiMessages(messages)
@@ -663,13 +681,15 @@ export const useChatStore = create<ChatStore>((set, get) => ({
       get().handleServerMessage(sessionId, msg)
     })
 
-    const runtimeSelection = useSessionRuntimeStore.getState().selections[sessionId]
-    if (runtimeSelection) {
-      wsManager.send(sessionId, { type: 'set_runtime_config', ...runtimeSelection })
-    }
-    if (!sessionId.startsWith('__') && !useTeamStore.getState().getMemberBySessionId(sessionId)) {
-      wsManager.send(sessionId, { type: 'prewarm_session' })
-    }
+    // Direct API mode: no sidecar runtime config to send
+    // const runtimeSelection = useSessionRuntimeStore.getState().selections[sessionId]
+    // if (runtimeSelection) {
+    //   wsManager.send(sessionId, { type: 'set_runtime_config', ...runtimeSelection })
+    // }
+    // Direct API mode: no CLI subprocess to prewarm
+    // if (!sessionId.startsWith('__') && !useTeamStore.getState().getMemberBySessionId(sessionId)) {
+    //   wsManager.send(sessionId, { type: 'prewarm_session' })
+    // }
 
     get().loadHistory(sessionId)
     sessionsApi.getSlashCommands(sessionId)
@@ -811,7 +831,8 @@ export const useChatStore = create<ChatStore>((set, get) => ({
       return
     }
 
-    wsManager.send(sessionId, { type: 'user_message', content, attachments })
+    // Use direct provider API instead of sidecar CLI subprocess
+    get().startDirectConversation(sessionId, modelFacingContent)
   },
 
   respondToPermission: (sessionId, requestId, allowed, options) => {
@@ -852,29 +873,197 @@ export const useChatStore = create<ChatStore>((set, get) => ({
   },
 
   stopGeneration: (sessionId) => {
-    wsManager.send(sessionId, { type: 'stop_generation' })
+    // Direct transport: no WebSocket to send stop signal to.
+    // For now, aborts are not supported in direct mode.
+    // The session will complete the current response naturally.
     if (pendingDeltaBySession.has(sessionId)) {
       const text = consumePendingDelta(sessionId)
       set((s) => ({ sessions: updateSessionIn(s.sessions, sessionId, (sess) => ({ streamingText: sess.streamingText + text })) }))
     }
-    set((s) => {
-      const session = s.sessions[sessionId]
-      if (!session) return s
-      if (session.elapsedTimer) clearInterval(session.elapsedTimer)
-      return {
-        sessions: {
-          ...s.sessions,
-          [sessionId]: {
-            ...session,
-            chatState: 'idle',
-            pendingPermission: null,
-            pendingComputerUsePermission: null,
-            apiRetry: null,
-            elapsedTimer: null,
-          },
-        },
+    clearPendingTaskToolUseIds(sessionId)
+    clearPendingToolParentUseIds(sessionId)
+  },
+
+  startDirectConversation: async (sessionId, _content) => {
+    const session = get().sessions[sessionId]
+    if (!session) return
+
+    // Build conversation history from existing messages.
+    // The user's new message is already in session.messages (added by sendMessage's
+    // synchronous set()), so no need to push it again.
+    const history = buildConversationHistory(session.messages)
+
+    // Use runtime-selected model if available (set via desktop session settings)
+    const runtimeSelection = useSessionRuntimeStore.getState().selections[sessionId]
+    const sendOptions: { model?: string } = {}
+    if (runtimeSelection?.modelId) {
+      sendOptions.model = runtimeSelection.modelId
+    }
+
+    try {
+      const stream = tuiConversation.sendMessage(history, sendOptions)
+      for await (const event of stream) {
+        switch (event.type) {
+          case 'content_block_start': {
+            if (event.blockType === 'text') {
+              set((s) => ({
+                sessions: updateSessionIn(s.sessions, sessionId, () => ({
+                  chatState: 'streaming',
+                  apiRetry: null,
+                })),
+              }))
+            }
+            break
+          }
+
+          case 'text_delta': {
+            appendPendingDelta(sessionId, event.text)
+            if (!flushTimerBySession.has(sessionId)) {
+              const timer = setTimeout(() => {
+                const text = pendingDeltaBySession.get(sessionId) ?? ''
+                pendingDeltaBySession.delete(sessionId)
+                flushTimerBySession.delete(sessionId)
+                set((s) => ({
+                  sessions: updateSessionIn(s.sessions, sessionId, (sess) => ({
+                    streamingText: sess.streamingText + text,
+                  })),
+                }))
+              }, 50)
+              flushTimerBySession.set(sessionId, timer)
+            }
+            break
+          }
+
+          case 'thinking_delta': {
+            set((s) => {
+              const sess = s.sessions[sessionId] ?? createDefaultSessionState()
+              const pendingText = `${sess.streamingText}${consumePendingDelta(sessionId)}`
+              let base = sess.messages
+              if (pendingText.trim()) {
+                base = appendAssistantTextMessage(base, pendingText, Date.now())
+              }
+              const last = base[base.length - 1]
+              if (last && last.type === 'thinking') {
+                const updated = [...base]
+                updated[updated.length - 1] = {
+                  ...last,
+                  content: last.content + event.thinking,
+                }
+                return {
+                  sessions: updateSessionIn(s.sessions, sessionId, () => ({
+                    messages: updated,
+                    chatState: 'thinking',
+                    activeThinkingId: last.id,
+                    streamingText: '',
+                  })),
+                }
+              }
+              const id = nextId()
+              return {
+                sessions: updateSessionIn(s.sessions, sessionId, () => ({
+                  messages: [
+                    ...base,
+                    { id, type: 'thinking', content: event.thinking, timestamp: Date.now() },
+                  ],
+                  chatState: 'thinking',
+                  activeThinkingId: id,
+                  streamingText: '',
+                })),
+              }
+            })
+            break
+          }
+
+          case 'content_block_stop': {
+            const pendingText = consumePendingDelta(sessionId)
+            set((s) => ({
+              sessions: updateSessionIn(s.sessions, sessionId, (sess) => {
+                const accumulatedText = `${sess.streamingText}${pendingText}`
+                if (!accumulatedText.trim()) return {}
+                return {
+                  messages: appendAssistantTextMessage(sess.messages, accumulatedText, Date.now()),
+                  streamingText: '',
+                }
+              }),
+            }))
+            break
+          }
+
+          case 'message_stop': {
+            // Flush any remaining pending delta
+            const remainingText = consumePendingDelta(sessionId)
+            if (remainingText.trim()) {
+              set((s) => ({
+                sessions: updateSessionIn(s.sessions, sessionId, (sess) => ({
+                  messages: appendAssistantTextMessage(
+                    sess.messages,
+                    `${sess.streamingText}${remainingText}`,
+                    Date.now(),
+                  ),
+                  streamingText: '',
+                })),
+              }))
+            }
+            const sess = get().sessions[sessionId]
+            if (sess?.elapsedTimer) {
+              clearInterval(sess.elapsedTimer)
+            }
+            set((s) => ({
+              sessions: updateSessionIn(s.sessions, sessionId, () => ({
+                chatState: 'idle',
+                elapsedTimer: null,
+                statusVerb: '',
+              })),
+            }))
+            break
+          }
+
+          case 'done':
+            break
+
+          case 'error': {
+            set((s) => ({
+              sessions: updateSessionIn(s.sessions, sessionId, (sess) => ({
+                chatState: 'idle',
+                messages: [
+                  ...sess.messages,
+                  {
+                    id: nextId(),
+                    type: 'error',
+                    message: event.message,
+                    code: 'CLI_ERROR',
+                    timestamp: Date.now(),
+                  } as UIMessage,
+                ],
+              })),
+            }))
+            break
+          }
+        }
       }
-    })
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      const sess = get().sessions[sessionId]
+      if (sess?.elapsedTimer) {
+        clearInterval(sess.elapsedTimer)
+      }
+      set((s) => ({
+        sessions: updateSessionIn(s.sessions, sessionId, (sess) => ({
+          chatState: 'idle',
+          elapsedTimer: null,
+          messages: [
+            ...sess.messages,
+            {
+              id: nextId(),
+              type: 'error',
+              message,
+              code: 'CLI_ERROR',
+              timestamp: Date.now(),
+            } as UIMessage,
+          ],
+        })),
+      }))
+    }
   },
 
   loadHistory: async (sessionId) => {

desktop/src/stores/cliAuthStore.ts

@@ -1,5 +1,13 @@
+/**
+ * Desktop auth store that reads/writes ~/.claude.json directly via Rust Tauri commands.
+ * Mirrors TUI's src/utils/auth.ts save* functions.
+ *
+ * This removes the dependency on cc-haha's /api/cli-auth HTTP endpoint.
+ */
 import { create } from 'zustand'
-import { cliAuthApi, type AuthProvider, type CliAuthConfig } from '../api/cliAuth'
+import { getTuiConfig, saveTuiConfigPatch, clearConfigCache } from '../api/config'
+
+type AuthProvider = 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode' | 'nvidia'
 
 type CliAuthStore = {
   authProvider: AuthProvider | null
@@ -38,16 +46,19 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   fetchAuth: async () => {
     set({ isLoading: true, error: null })
     try {
-      const config = await cliAuthApi.get()
+      const config = await getTuiConfig()
+      // Map TUI's authProvider names to our store's names
+      // TUI uses 'anthropic' → our 'anthropic' means firstParty
+      const authProvider = config.authProvider ?? null
       set({
-        authProvider: config.authProvider,
-        nvidiaApiKey: config.nvidiaApiKey || null,
-        openRouterApiKey: config.openRouterApiKey || null,
-        openAiApiKey: config.openAiApiKey || config.openAiAccessToken || null,
-        openCodeApiKey: config.openCodeApiKey || null,
-        openCodeModelName: config.openCodeModelName || null,
-        localBaseUrl: config.localBaseUrl || null,
-        localModelName: config.localModelName || null,
+        authProvider,
+        nvidiaApiKey: config.nvidiaApiKey ?? null,
+        openRouterApiKey: config.openRouterApiKey ?? null,
+        openAiApiKey: (config.openAiApiKey || config.openAiAccessToken) ?? null,
+        openCodeApiKey: config.openCodeApiKey ?? null,
+        openCodeModelName: config.openCodeModelName ?? null,
+        localBaseUrl: config.localBaseUrl ?? null,
+        localModelName: config.localModelName ?? null,
         isLoading: false,
       })
     } catch (err) {
@@ -58,8 +69,8 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   setAuthProvider: async (provider: AuthProvider) => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: provider })
-      await cliAuthApi.invalidateCache()
+      await saveTuiConfigPatch({ authProvider: provider })
+      clearConfigCache()
       set({ authProvider: provider, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -69,8 +80,11 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   saveNvidiaApiKey: async (apiKey: string) => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: 'nvidia', nvidiaApiKey: apiKey })
-      await cliAuthApi.invalidateCache()
+      await saveTuiConfigPatch({
+        authProvider: 'nvidia',
+        nvidiaApiKey: apiKey,
+      })
+      clearConfigCache()
       set({ authProvider: 'nvidia', nvidiaApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -80,8 +94,11 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   saveOpenRouterApiKey: async (apiKey: string) => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: 'openrouter', openRouterApiKey: apiKey })
-      await cliAuthApi.invalidateCache()
+      await saveTuiConfigPatch({
+        authProvider: 'openrouter',
+        openRouterApiKey: apiKey,
+      })
+      clearConfigCache()
       set({ authProvider: 'openrouter', openRouterApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -91,8 +108,12 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   saveOpenAIApiKey: async (apiKey: string) => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: 'openai', openAiApiKey: apiKey })
-      await cliAuthApi.invalidateCache()
+      await saveTuiConfigPatch({
+        authProvider: 'openai',
+        openAiApiKey: apiKey,
+        openAiAccessToken: undefined, // Clear OAuth token when switching to API key
+      })
+      clearConfigCache()
       set({ authProvider: 'openai', openAiApiKey: apiKey, isLoading: false })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
@@ -102,10 +123,12 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   saveOpenCodeApiKey: async (apiKey: string, modelName?: string) => {
     set({ isLoading: true, error: null })
     try {
-      const updates: Record<string, unknown> = { authProvider: 'opencode', openCodeApiKey: apiKey }
-      if (modelName) updates.openCodeModelName = modelName
-      await cliAuthApi.update(updates as Partial<CliAuthConfig>)
-      await cliAuthApi.invalidateCache()
+      await saveTuiConfigPatch({
+        authProvider: 'opencode',
+        openCodeApiKey: apiKey || undefined,
+        openCodeModelName: modelName || undefined,
+      })
+      clearConfigCache()
       set({
         authProvider: 'opencode',
         openCodeApiKey: apiKey,
@@ -120,9 +143,18 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   saveLocalModelConfig: async (baseUrl: string, modelName: string) => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: 'local', localBaseUrl: baseUrl, localModelName: modelName })
-      await cliAuthApi.invalidateCache()
-      set({ authProvider: 'local', localBaseUrl: baseUrl, localModelName: modelName, isLoading: false })
+      await saveTuiConfigPatch({
+        authProvider: 'local',
+        localBaseUrl: baseUrl,
+        localModelName: modelName,
+      })
+      clearConfigCache()
+      set({
+        authProvider: 'local',
+        localBaseUrl: baseUrl,
+        localModelName: modelName,
+        isLoading: false,
+      })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
     }
@@ -131,11 +163,33 @@ export const useCliAuthStore = create<CliAuthStore>((set) => ({
   clearAuth: async () => {
     set({ isLoading: true, error: null })
     try {
-      await cliAuthApi.update({ authProvider: null })
-      await cliAuthApi.invalidateCache()
-      set({ authProvider: null, nvidiaApiKey: null, openRouterApiKey: null, openAiApiKey: null, openCodeApiKey: null, localBaseUrl: null, localModelName: null, isLoading: false })
+      // Clear by writing null values for all auth fields
+      await saveTuiConfigPatch({
+        authProvider: null,
+        primaryApiKey: undefined,
+        openAiApiKey: undefined,
+        openAiAccessToken: undefined,
+        openRouterApiKey: undefined,
+        nvidiaApiKey: undefined,
+        openCodeApiKey: undefined,
+        openCodeModelName: undefined,
+        localBaseUrl: undefined,
+        localModelName: undefined,
+      })
+      clearConfigCache()
+      set({
+        authProvider: null,
+        nvidiaApiKey: null,
+        openRouterApiKey: null,
+        openAiApiKey: null,
+        openCodeApiKey: null,
+        openCodeModelName: null,
+        localBaseUrl: null,
+        localModelName: null,
+        isLoading: false,
+      })
     } catch (err) {
       set({ isLoading: false, error: err instanceof Error ? err.message : String(err) })
     }
   },
-}))
+}))

desktop/src/stores/providerStore.ts

@@ -10,6 +10,7 @@ import {
   OPENAI_OFFICIAL_DEFAULT_MODEL_ID,
   OPENAI_OFFICIAL_PROVIDER_ID,
 } from '../constants/openaiOfficialProvider'
+import { saveTuiConfigPatch, clearConfigCache } from '../api/config'
 import type {
   SavedProvider,
   CreateProviderInput,
@@ -48,6 +49,34 @@ function providerModelIds(provider: SavedProvider): Set<string> {
   )
 }
 
+/** Map a sidecar SavedProvider to TUI ~/.claude.json authProvider fields */
+type TuiProviderMapping = { authProvider: string; apiKeyField: string; apiKey?: string } | null
+function mapSidecarToTuiProvider(provider: SavedProvider): TuiProviderMapping {
+  const apiFormat = provider.apiFormat || 'anthropic'
+  switch (apiFormat) {
+    case 'anthropic':
+      return { authProvider: 'anthropic', apiKeyField: 'anthropicApiKey', apiKey: provider.apiKey }
+    case 'openai': {
+      // Try to infer specific provider from base URL or name
+      const baseUrl = (provider.baseUrl || '').toLowerCase()
+      const name = (provider.name || '').toLowerCase()
+      if (baseUrl.includes('nvidia') || name.includes('nvidia')) {
+        return { authProvider: 'nvidia', apiKeyField: 'nvidiaApiKey', apiKey: provider.apiKey }
+      }
+      if (baseUrl.includes('openrouter') || name.includes('openrouter')) {
+        return { authProvider: 'openrouter', apiKeyField: 'openRouterApiKey', apiKey: provider.apiKey }
+      }
+      if (baseUrl.includes('opencode') || name.includes('opencode')) {
+        return { authProvider: 'opencode', apiKeyField: 'openCodeApiKey', apiKey: provider.apiKey }
+      }
+      // Generic OpenAI-compatible
+      return { authProvider: 'openai', apiKeyField: 'openAiApiKey', apiKey: provider.apiKey }
+    }
+    default:
+      return null
+  }
+}
+
 function resolveRuntimeRefreshSelection(
   provider: SavedProvider,
   activeId: string | null,
@@ -147,10 +176,11 @@ export const useProviderStore = create<ProviderStore>((set, get) => ({
   activateProvider: async (id) => {
     await providersApi.activate(id)
     await get().fetchProviders()
-    // 更新默认 provider 时，同步刷新默认 model，避免 settings.json 里残留
-    // 旧 provider 的 model id 导致默认选择指向不存在的模型。
+    // 同步 provider 信息到 ~/.claude.json，这样 fetchProviderModels() / tuiConversation
+    // 可以直接通过 TUI 方式来读取配置，无需依赖 sidecar。
     const settings = useSettingsStore.getState()
     if (id === OPENAI_OFFICIAL_PROVIDER_ID) {
+      await saveTuiConfigPatch({ authProvider: 'anthropic' })
       await settings.setModel(OPENAI_OFFICIAL_DEFAULT_MODEL_ID)
       await settings.fetchAll()
       return
@@ -158,10 +188,33 @@ export const useProviderStore = create<ProviderStore>((set, get) => ({
 
     const provider = get().providers.find((p) => p.id === id)
     if (!provider) return
+
+    // Map sidecar apiFormat to TUI authProvider
+    const tuiProvider = mapSidecarToTuiProvider(provider)
+    const patch: Record<string, unknown> = {}
+    if (tuiProvider) {
+      patch.authProvider = tuiProvider.authProvider
+      if (tuiProvider.apiKey) patch[tuiProvider.apiKeyField] = tuiProvider.apiKey
+    }
+    patch.model = provider.models.main
+    await saveTuiConfigPatch(patch)
+    clearConfigCache()
+
     await settings.setModel(provider.models.main)
     await settings.fetchAll()
   },
 
+  activateOfficial: async () => {
+    await providersApi.activateOfficial()
+    await get().fetchProviders()
+    // 同步回 Anthropic first-party
+    await saveTuiConfigPatch({ authProvider: 'anthropic' })
+    clearConfigCache()
+    const settings = useSettingsStore.getState()
+    await settings.setModel(OFFICIAL_DEFAULT_MODEL_ID)
+    await settings.fetchAll()
+  },
+
   activateOfficial: async () => {
     await providersApi.activateOfficial()
     await get().fetchProviders()

desktop/src/stores/settingsStore.ts

@@ -3,6 +3,8 @@ import { ApiError } from '../api/client'
 import { settingsApi } from '../api/settings'
 import { modelsApi } from '../api/models'
 import { h5AccessApi } from '../api/h5Access'
+import { fetchProviderModels } from '../api/providerModels'
+import { getTuiConfig, saveTuiConfigPatch } from '../api/config'
 import {
   isThemeMode,
   type AppMode,
@@ -170,23 +172,60 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     set({ isLoading: true, error: null })
     try {
       const previousH5Access = get().h5Access
-      const [{ mode }, modelsRes, { model }, { level }, userSettings, h5AccessResult] = await Promise.all([
+      const [directModels, { mode }, config, userSettings, h5AccessResult] = await Promise.all([
+        // Fetch models directly from provider APIs (TUI-style)
+        fetchProviderModels().catch(() => ({ models: [] as ModelInfo[], provider: null as { id: string; name: string } | null })),
         settingsApi.getPermissionMode(),
-        modelsApi.list(),
-        modelsApi.getCurrent(),
-        modelsApi.getEffort(),
+        // Read model + effort from ~/.claude.json (TUI-style), bypassing sidecar
+        getTuiConfig(),
         settingsApi.getUser(),
         loadH5AccessSettings(previousH5Access),
       ])
+
+      // Use direct models if available (TUI-style), otherwise fall back to sidecar
+      let availableModels: ModelInfo[]
+      let activeProviderId: string | null
+      let activeProviderName: string | null
+
+      if (directModels.models.length > 0) {
+        availableModels = directModels.models
+        activeProviderId = directModels.provider?.id ?? null
+        activeProviderName = directModels.provider?.name ?? null
+      } else {
+        const sidecarRes = await modelsApi.list().catch(() => null)
+        if (sidecarRes && sidecarRes.models.length > 0) {
+          availableModels = sidecarRes.models
+          activeProviderId = sidecarRes.provider?.id ?? null
+          activeProviderName = sidecarRes.provider?.name ?? null
+        } else {
+          availableModels = []
+          activeProviderId = null
+          activeProviderName = null
+        }
+      }
+
+      // Derive currentModel from config's model field, matched against availableModels
+      const configModelId = config.model ?? null
+      const currentModel: ModelInfo | null = configModelId
+        ? availableModels.find((m) => m.id === configModelId) ?? {
+            id: configModelId,
+            name: configModelId,
+            description: '',
+            context: '',
+          }
+        : null
+      const effortLevel: EffortLevel =
+        (config.effortLevel as EffortLevel) ?? 'medium'
+
       const theme = isThemeMode(userSettings.theme) ? userSettings.theme : 'white'
       useUIStore.getState().setTheme(theme)
       set({
         permissionMode: mode,
-        availableModels: modelsRes.models,
-        activeProviderId: modelsRes.provider?.id ?? null,
-        activeProviderName: modelsRes.provider?.name ?? null,
-        currentModel: model,
-        effortLevel: level,
+        availableModels,
+        activeProviderId,
+        activeProviderName,
+        currentModel,
+        effortLevel,
         thinkingEnabled: userSettings.alwaysThinkingEnabled !== false,
         theme,
         skipWebFetchPreflight: userSettings.skipWebFetchPreflight !== false,
@@ -225,16 +264,22 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
   },
 
   setModel: async (modelId) => {
-    await modelsApi.setCurrent(modelId)
-    const { model } = await modelsApi.getCurrent()
-    set({ currentModel: model })
+    await saveTuiConfigPatch({ model: modelId })
+    const availableModels = get().availableModels
+    const currentModel: ModelInfo | null = availableModels.find((m) => m.id === modelId) ?? {
+      id: modelId,
+      name: modelId,
+      description: '',
+      context: '',
+    }
+    set({ currentModel })
   },
 
   setEffort: async (level) => {
     const prev = get().effortLevel
     set({ effortLevel: level })
     try {
-      await modelsApi.setEffort(level)
+      await saveTuiConfigPatch({ effortLevel: level })
     } catch {
       set({ effortLevel: prev })
     }

src/components/Messages.tsx

@@ -544,7 +544,7 @@ const MessagesImpl = ({
   }, [collapsed_0, renderRange, virtualScrollRuntimeGate, disableRenderCap]);
   const streamingToolUseIDs = useMemo(() => new Set(streamingToolUses.map(__0 => __0.contentBlock.id)), [streamingToolUses]);
 
-  useAutoTTS(renderableMessages);
+  useAutoTTS(renderableMessages, isLoading);
 
   // Divider insertion point: first renderableMessage whose uuid shares the
   // 24-char prefix with firstUnseenUuid (deriveUUID keeps the first 24

src/hooks/useAutoTTS.ts

@@ -24,27 +24,47 @@ function resolveEdgeTTSVoice(language: string | undefined, explicitVoice: string
   return 'en-US-JennyNeural'
 }
 
-export function useAutoTTS(messages: RenderableMessage[]): void {
+export function useAutoTTS(messages: RenderableMessage[], isLoading?: boolean): void {
   const triggeredIdsRef = useRef<Set<string>>(new Set())
   const pendingPlayRef = useRef<Promise<void> | null>(null)
 
+  // Snapshot of message IDs present when the conversation first becomes "active".
+  // isLoading goes true on the first user submit and stays false on resume.
+  // By waiting for isLoading=true we ensure the snapshot captures the correct
+  // boundary: everything before it is history (skip), everything after is new.
+  const historyIdsRef = useRef<Set<string> | null>(null)
+  const wasLoadingRef = useRef<boolean>(false)
+
   useEffect(() => {
     const settings = getInitialSettings()
     if (!settings.voiceAutoTTS || !settings.voiceEnabled) return
 
+    // Capture history snapshot on the transition from idle → active.
+    // This fires once: when the user first submits a message in a fresh REPL,
+    // or (importantly) never during a resume where isLoading stays false.
+    if (!historyIdsRef.current && !wasLoadingRef.current && isLoading) {
+      historyIdsRef.current = new Set(messages.map(m => m.uuid))
+    }
+    wasLoadingRef.current = isLoading ?? false
+
+    const voice = resolveEdgeTTSVoice(
+      settings.voiceLanguage || settings.language,
+      settings.voiceTTSVoice,
+    )
+
     for (const msg of messages) {
-      if (msg.type !== 'assistant') continue
       if (triggeredIdsRef.current.has(msg.uuid)) continue
+      // Skip messages that were present before the conversation became active.
+      if (historyIdsRef.current?.has(msg.uuid)) continue
 
+      triggeredIdsRef.current.add(msg.uuid)
+
+      if (msg.type !== 'assistant') continue
       const content = msg.message.content[0]
       if (content?.type !== 'text') continue
       if (!content.text.trim()) continue
 
-      triggeredIdsRef.current.add(msg.uuid)
-
       const text = content.text
-      const language = settings.voiceLanguage || settings.language
-      const voice = resolveEdgeTTSVoice(language, settings.voiceTTSVoice)
 
       const run = async () => {
         const result = await speakWithEdgeTTS(text, {
@@ -62,5 +82,5 @@ export function useAutoTTS(messages: RenderableMessage[]): void {
         pendingPlayRef.current = run().catch(() => {})
       }
     }
-  }, [messages])
+  }, [messages, isLoading])
 }