diff --git a/docs/en/wework/settings.md b/docs/en/wework/settings.md
index d6a9ddb9ce..c8e832372e 100644
--- a/docs/en/wework/settings.md
+++ b/docs/en/wework/settings.md
@@ -32,13 +32,30 @@ Common macOS shortcuts include:
 local custom models, and cloud models remain available according to their own configuration. If
 no source provides a model, the picker displays **No models available**.
 
+## Friendly titles
+
+Under **Settings → General → Task runtime**, enable **Use friendly titles** and select an available model. Wework
+then generates a concise title asynchronously for each new task. Creation never waits for that
+model: the task starts with the original user-provided title, and its display name is replaced
+when generation finishes with a brief shimmer.
+
+Title generation uses a separate lightweight model call. It does not add a message to the task
+conversation or change the main task's running, completed, or failed state. A manually renamed
+task is not overwritten later. If generation fails, the original title remains and the task still
+starts normally.
+
+Ordinary new tasks are standalone by default. Opening a project task earlier does not
+automatically add a new task to a remote project or board. Wework synchronizes only tasks that
+were explicitly linked to a project space; after friendly-title generation, those local or cloud
+board items receive the updated title.
+
 ## Custom Codex models
 
 In **Settings → Models**, click **Add model** and choose a provider first. Wework includes profiles for Kimi Coding, the Kimi API Platform, DeepSeek, and GLM. After entering the corresponding platform API key, Wework discovers available models through the provider's `/models` endpoint. Each profile supplies its connection URL, API protocol, tool mode, and known model context windows; the Kimi API Platform profile uses the China-region `api.moonshot.cn` endpoint. Kimi Coding K3 automatically uses the built-in Codex Catalog profile with a 256K context window and `low` default reasoning effort.
 
 The DeepSeek profile uses the native Responses API and exposes `deepseek-v4-flash` and `deepseek-v4-pro`, the models currently available for Codex. Both use a 1,048,576-token context window, `high` default reasoning effort, live Web Search, and freeform `apply_patch`. The connection test also requires a real `apply_patch` custom-tool call. Existing Wework-managed DeepSeek Chat Completions configurations are migrated to the Responses API. The current catalog declares text input and disables image generation, so image generation and image understanding are not presented as supported capabilities for this profile.
 
- A text-only model can reference another model that explicitly declares image input as its vision proxy. Local-model references are maintained in Wework's local model settings. Cloud-model references must be configured in the Wegent web administration UI; Wework only consumes the `visionSidecarModel` reference returned by the Backend and does not provide cloud-model editing. Before the primary request, Wework asks the vision model to describe each image and replaces `input_image` with the description text. Every text model with a configured vision proxy uses the internal generic `wework-vision-sidecar` capability catalog entry, allowing Codex to accept images while sending the original media only to the vision model and never to the text-only primary model. Vision proxies support OpenAI Responses, OpenAI Chat Completions, and Anthropic Messages endpoints. Each turn describes at most eight distinct images, accepts images up to 20 MB, and injects an explicit error message when description fails. Remote vision endpoints must use HTTPS; only `localhost` and loopback IP addresses may use HTTP, and vision requests do not follow redirects so credentials cannot be forwarded to an unauthorized destination.
+A text-only model can reference another model that explicitly declares image input as its vision proxy. Local-model references are maintained in Wework's local model settings. Cloud-model references must be configured in the Wegent web administration UI; Wework only consumes the `visionSidecarModel` reference returned by the Backend and does not provide cloud-model editing. Before the primary request, Wework asks the vision model to describe each image and replaces `input_image` with the description text. Every text model with a configured vision proxy uses the internal generic `wework-vision-sidecar` capability catalog entry, allowing Codex to accept images while sending the original media only to the vision model and never to the text-only primary model. Vision proxies support OpenAI Responses, OpenAI Chat Completions, and Anthropic Messages endpoints. Each turn describes at most eight distinct images, accepts images up to 20 MB, and injects an explicit error message when description fails. Remote vision endpoints must use HTTPS; only `localhost` and loopback IP addresses may use HTTP, and vision requests do not follow redirects so credentials cannot be forwarded to an unauthorized destination.
 
 Each custom model has an optional **Group** field that controls how it appears in the model picker. Kimi Coding defaults this field to **Kimi**, but users can edit or clear it. Models without a group appear under **Custom models**.
 
diff --git a/docs/zh/wework/settings.md b/docs/zh/wework/settings.md
index c2cd2f83ed..4432268275 100644
--- a/docs/zh/wework/settings.md
+++ b/docs/zh/wework/settings.md
@@ -42,13 +42,27 @@ Windows 和 Linux 使用界面中显示的对应组合键。
 `auth.json` 时，该分组不会出现在模型选择器中；Provider 模型、本地自定义模型和云端模型
 仍按各自配置展示。如果所有来源都没有可用模型，选择器直接显示“暂无可用模型”。
 
+## 使用友好标题
+
+在 **设置 → 通用 → 任务运行** 中打开 **使用友好标题**，并选择一个可用模型后，Wework 会在新建任务
+时异步生成简洁的中文标题。创建不会等待标题模型返回：任务先使用用户输入的原始标题创建，
+标题生成完成后才替换显示名称并出现短暂扫光效果。
+
+标题生成使用独立的轻量模型调用，不会向任务会话写入消息，也不会改变主任务的运行、完成或
+失败状态。手动重命名的任务不会被之后的自动标题覆盖。生成失败时，原始标题会保留，任务仍可
+正常创建和运行。
+
+普通新建任务默认是独立会话，不会因为之前打开过项目任务而自动加入远程项目或看板。只有在
+发送前明确选择项目空间，或为任务显式关联项目空间时，Wework 才会同步该任务；已关联的任务
+在友好标题生成后会将更新后的标题同步到对应的本地或云端看板。
+
 ## 自定义 Codex 模型
 
 在“设置 → 模型”中点击“添加模型”后，先选择提供商。Wework 内置 Kimi Coding、Kimi 开放平台、DeepSeek 和 GLM profile；填写对应平台的 API Key 后，可以从提供商的 `/models` 接口读取可用模型。连接地址、接口协议、工具模式和已知模型的上下文长度由 profile 自动填写，其中 Kimi 开放平台使用中国区 `api.moonshot.cn` 端点。Kimi Coding 的 K3 会自动使用内置的 Codex Catalog profile，包括 256K 上下文和默认 `low` 推理等级。
 
 DeepSeek profile 使用原生 Responses API，展示当前可用于 Codex 的 `deepseek-v4-flash` 和 `deepseek-v4-pro`。两者均使用 1,048,576 tokens 上下文、默认 `high` 推理等级、实时 Web Search 和 freeform `apply_patch`；连接测试也会要求模型真实返回 `apply_patch` custom tool call。旧版由 Wework 管理的 DeepSeek Chat Completions 配置会自动迁移到 Responses API。当前模型目录声明文本输入且关闭图片生成，因此图片生成和图片理解不会在该 profile 下显示为可用能力。
 
- 文本模型可以引用另一个明确声明图片输入能力的模型作为“视觉代理模型”。本地模型的引用在 Wework 本地模型设置中维护；云端模型的引用必须在 Wegent Web 管理端配置，Wework 只读取 Backend 下发的 `visionSidecarModel` 引用，不提供云端模型编辑入口。执行时，Wework 在请求主模型前调用视觉模型描述每张图片，再用描述文本替换 `input_image`。任何配置视觉代理的文本模型都会使用内部通用的 `wework-vision-sidecar` 能力目录项，使 Codex 可以接收图片，同时原始图片只发送给视觉模型，不发送给文本主模型。视觉代理支持 OpenAI Responses、OpenAI Chat Completions 和 Anthropic Messages 接口；单轮最多处理 8 个不同图片描述，单张图片最大 20 MB，描述失败时会插入明确的错误文本。远程视觉接口必须使用 HTTPS；仅 `localhost` 和回环 IP 可使用 HTTP，且视觉请求不会跟随重定向，避免凭证被发送到未授权的后续地址。
+文本模型可以引用另一个明确声明图片输入能力的模型作为“视觉代理模型”。本地模型的引用在 Wework 本地模型设置中维护；云端模型的引用必须在 Wegent Web 管理端配置，Wework 只读取 Backend 下发的 `visionSidecarModel` 引用，不提供云端模型编辑入口。执行时，Wework 在请求主模型前调用视觉模型描述每张图片，再用描述文本替换 `input_image`。任何配置视觉代理的文本模型都会使用内部通用的 `wework-vision-sidecar` 能力目录项，使 Codex 可以接收图片，同时原始图片只发送给视觉模型，不发送给文本主模型。视觉代理支持 OpenAI Responses、OpenAI Chat Completions 和 Anthropic Messages 接口；单轮最多处理 8 个不同图片描述，单张图片最大 20 MB，描述失败时会插入明确的错误文本。远程视觉接口必须使用 HTTPS；仅 `localhost` 和回环 IP 可使用 HTTP，且视觉请求不会跟随重定向，避免凭证被发送到未授权的后续地址。
 
 每个自定义模型都可以设置可选的“分组”，模型选择器会使用该名称组织模型。Kimi Coding 默认填写“Kimi”，用户可以修改或清空；未设置分组的模型统一显示在“自定义模型”下。
 
diff --git a/executor/src/runtime_work/handler/tasks.rs b/executor/src/runtime_work/handler/tasks.rs
index f3b04c49fe..9be4fda93e 100644
--- a/executor/src/runtime_work/handler/tasks.rs
+++ b/executor/src/runtime_work/handler/tasks.rs
@@ -5,6 +5,146 @@
 use super::*;
 
 impl RuntimeWorkRpcHandler {
+    pub(super) async fn generate_friendly_title(
+        &self,
+        payload: Value,
+    ) -> Result<Value, AppIpcError> {
+        let source_title = string_field(&payload, "sourceTitle")
+            .or_else(|| string_field(&payload, "source_title"))
+            .ok_or_else(|| AppIpcError::new("bad_request", "sourceTitle is required"))?;
+        let link = self.task_link_from_payload(&payload, false).await?;
+        if link.title != source_title {
+            log_executor_event(
+                "friendly task title generation skipped",
+                &[
+                    ("local_task_id", link.local_task_id),
+                    ("reason", "title_changed_before_generation".to_owned()),
+                ],
+            );
+            return Ok(json!({"success": true, "skipped": true}));
+        }
+        let local_task_id = link.local_task_id.clone();
+        let mut request = execution_request(&payload)
+            .ok_or_else(|| AppIpcError::new("bad_request", "executionRequest is required"))?;
+        request.ephemeral = true;
+        let result = self
+            .codex_app_server
+            .run_turn_with_cancel(request.clone(), CodexAppServerTurnOptions::default())
+            .await;
+        let content = match result {
+            Ok(turn) => match turn.outcome {
+                ExecutionOutcome::Completed { content } => content,
+                ExecutionOutcome::Failed { message } => {
+                    log_executor_event(
+                        "friendly task title generation failed",
+                        &[
+                            ("local_task_id", local_task_id.clone()),
+                            ("reason", "model_request_failed".to_owned()),
+                            ("error", message.clone()),
+                        ],
+                    );
+                    return Ok(json!({"success": false, "error": message}));
+                }
+                outcome => {
+                    let error = format!("friendly title generation did not complete: {outcome:?}");
+                    log_executor_event(
+                        "friendly task title generation failed",
+                        &[
+                            ("local_task_id", local_task_id.clone()),
+                            ("reason", "model_request_incomplete".to_owned()),
+                            ("error", error.clone()),
+                        ],
+                    );
+                    return Ok(json!({"success": false, "error": error}));
+                }
+            },
+            Err(error) => {
+                log_executor_event(
+                    "friendly task title generation failed",
+                    &[
+                        ("local_task_id", local_task_id.clone()),
+                        ("reason", "model_transport_failed".to_owned()),
+                        ("error", error.clone()),
+                    ],
+                );
+                return Ok(json!({"success": false, "error": error}));
+            }
+        };
+        let Some(title) = normalize_friendly_title(&content) else {
+            log_executor_event(
+                "friendly task title generation failed",
+                &[
+                    ("local_task_id", local_task_id.clone()),
+                    ("reason", "empty_model_output".to_owned()),
+                ],
+            );
+            return Ok(json!({"success": false, "error": "friendly title was empty"}));
+        };
+        let mut latest_link = self.task_link_from_payload(&payload, false).await?;
+        for _ in 0..25 {
+            if latest_link.title != source_title {
+                log_executor_event(
+                    "friendly task title generation skipped",
+                    &[
+                        ("local_task_id", local_task_id.clone()),
+                        ("reason", "title_changed_during_generation".to_owned()),
+                    ],
+                );
+                return Ok(json!({"success": true, "skipped": true}));
+            }
+            if latest_link.thread_id.is_some() {
+                break;
+            }
+            sleep(Duration::from_millis(200)).await;
+            latest_link = self.task_link_from_payload(&payload, false).await?;
+        }
+        if latest_link.title != source_title {
+            log_executor_event(
+                "friendly task title generation skipped",
+                &[
+                    ("local_task_id", local_task_id.clone()),
+                    ("reason", "title_changed_before_update".to_owned()),
+                ],
+            );
+            return Ok(json!({"success": true, "skipped": true}));
+        }
+        if let Some(thread_id) = latest_link.thread_id.as_deref() {
+            if let Err(error) = self
+                .call_codex_thread_method(
+                    "thread/name/set",
+                    json!({"threadId": thread_id, "name": title}),
+                )
+                .await
+            {
+                log_executor_event(
+                    "friendly task title generation failed",
+                    &[
+                        ("local_task_id", local_task_id.clone()),
+                        ("reason", "thread_name_update_failed".to_owned()),
+                        ("error", error.clone()),
+                    ],
+                );
+                return Ok(json!({"success": false, "error": error}));
+            }
+        }
+        latest_link.title = title.clone();
+        latest_link.updated_at = now_ms();
+        self.upsert_local_task(latest_link);
+        emit_response_event(
+            &self.event_tx,
+            &self.device_id,
+            "runtime.task.title.updated",
+            &local_task_id,
+            &request,
+            json!({"title": title}),
+        );
+        log_executor_event(
+            "friendly task title generation completed",
+            &[("local_task_id", local_task_id)],
+        );
+        Ok(json!({"success": true, "title": title}))
+    }
+
     pub(super) async fn fork_task_at_turn(&self, payload: Value) -> Result<Value, AppIpcError> {
         let source = self.task_link_from_payload(&payload, false).await?;
         let requested_turn_id = string_field(&payload, "lastTurnId")
@@ -189,9 +329,49 @@ impl RuntimeWorkRpcHandler {
             fork_thread_id: side_source.as_ref().map(|source| source.thread_id.clone()),
             fork_thread_path: side_source.and_then(|source| source.thread_path),
             resume_thread_id: None,
-            initial_thread_name: Some(title),
+            initial_thread_name: Some(title.clone()),
             initial_thread_goal,
         });
+        match payload.get("friendlyTitleExecutionRequest").cloned() {
+            Some(value) => match serde_json::from_value::<ExecutionRequest>(value) {
+                Ok(execution_request) => {
+                    log_executor_event(
+                        "friendly task title generation queued",
+                        &[("local_task_id", local_task_id.clone())],
+                    );
+                    let handler = self.clone();
+                    let friendly_payload = json!({
+                        "taskId": local_task_id,
+                        "sourceTitle": title,
+                        "executionRequest": execution_request,
+                    });
+                    tokio::spawn(async move {
+                        if let Err(error) = handler.generate_friendly_title(friendly_payload).await
+                        {
+                            log_executor_event(
+                                "friendly task title generation failed",
+                                &[("error", error.message)],
+                            );
+                        }
+                    });
+                }
+                Err(error) => log_executor_event(
+                    "friendly task title generation rejected",
+                    &[
+                        ("local_task_id", local_task_id.clone()),
+                        ("reason", "invalid_execution_request".to_owned()),
+                        ("error", error.to_string()),
+                    ],
+                ),
+            },
+            None => log_executor_event(
+                "friendly task title generation skipped",
+                &[
+                    ("local_task_id", local_task_id.clone()),
+                    ("reason", "missing_execution_request".to_owned()),
+                ],
+            ),
+        }
 
         Ok(json!({
             "success": true,
@@ -801,6 +981,25 @@ impl RuntimeWorkRpcHandler {
     }
 }
 
+fn normalize_friendly_title(value: &str) -> Option<String> {
+    let title = value
+        .lines()
+        .find_map(|line| {
+            let trimmed = line
+                .trim()
+                .trim_matches(|ch| matches!(ch, '"' | '\'' | '“' | '”' | '‘' | '’' | '`'));
+            (!trimmed.is_empty()).then_some(trimmed)
+        })?
+        .chars()
+        .take(48)
+        .collect::<String>()
+        .trim()
+        .trim_end_matches(['。', '！', '？', '.', '!', '?'])
+        .trim()
+        .to_owned();
+    (!title.is_empty()).then_some(title)
+}
+
 pub(super) fn runtime_model_selection_changed(link: &RuntimeTaskLink, payload: &Value) -> bool {
     let previous = model_selection_identity(
         link.runtime_handle
@@ -914,3 +1113,21 @@ fn synthetic_transcript_turn_id_base(value: &str) -> Option<&str> {
     }
     Some(turn_id)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::normalize_friendly_title;
+
+    #[test]
+    fn normalizes_model_title_to_one_short_line() {
+        assert_eq!(
+            normalize_friendly_title("  “为任务创建友好标题。”\n这是解释"),
+            Some("为任务创建友好标题".to_owned())
+        );
+    }
+
+    #[test]
+    fn rejects_empty_model_title() {
+        assert_eq!(normalize_friendly_title(" \n\t "), None);
+    }
+}
diff --git a/wework/e2e/desktop/task-flow.e2e.mjs b/wework/e2e/desktop/task-flow.e2e.mjs
index dd9bc16053..0b770c07b9 100644
--- a/wework/e2e/desktop/task-flow.e2e.mjs
+++ b/wework/e2e/desktop/task-flow.e2e.mjs
@@ -315,9 +315,9 @@ const PROVIDER_SWITCH_LUNA_OPTION_ID = 'local-model:desktop-e2e-luna-overseas'
 const PROVIDER_SWITCH_LUNA_LABEL = 'GPT 5.6 Luna (海外)'
 const PROVIDER_SWITCH_LUNA_MODEL_ID = 'gpt-5.6-luna'
 // The local E2E Codex catalog is classified as third-party (custom provider), so
-// the official option is served from the cloud model catalog with a model id
-// that does not collide with the local Codex catalog.
-const PROVIDER_SWITCH_OFFICIAL_OPTION_ID = 'codex-gpt-5.5'
+// the official option is served from the cloud model catalog with a canonical
+// model id that does not collide with the local Codex catalog.
+const PROVIDER_SWITCH_OFFICIAL_OPTION_ID = 'gpt-5.5'
 const PROVIDER_SWITCH_OFFICIAL_LABEL = 'GPT 5.5'
 const PROVIDER_SWITCH_OFFICIAL_MODEL_ID = 'gpt-5.5'
 const PROVIDER_SWITCH_OFFICIAL_MODEL_LABEL = 'GPT 5.5'
@@ -13520,7 +13520,6 @@ last_updated = "2026-07-30T00:00:00Z"`
     await control.command('dispatchLocalModelSettingsChanged', '')
     const canonicalModelOption = `model-option-${DEFAULT_MODEL_ID}`
     const synthesizedModelOption = `model-option-codex-${DEFAULT_MODEL_ID}`
-    const legacyGpt55ModelOption = 'model-option-gpt-5.5'
     const publicModelOption = `model-option-${CLOUD_PUBLIC_MODEL_NAME}`
     const recoveredModelMenu = await ensureModelOptionVisible(control, canonicalModelOption)
     assert.equal(
@@ -13533,11 +13532,6 @@ last_updated = "2026-07-30T00:00:00Z"`
       false,
       'The Backend-synthesized runtime Codex duplicate remained visible'
     )
-    assert.equal(
-      recoveredModelMenu.testIds.includes(legacyGpt55ModelOption),
-      false,
-      'The legacy GPT 5.5 Codex model remained visible'
-    )
     assert.equal(
       (await ensureModelOptionVisible(control, publicModelOption)).testIds.includes(
         publicModelOption
diff --git a/wework/src-tauri/src/lib.rs b/wework/src-tauri/src/lib.rs
index 69515551c4..9342bcbdad 100644
--- a/wework/src-tauri/src/lib.rs
+++ b/wework/src-tauri/src/lib.rs
@@ -614,6 +614,10 @@ struct AppPreferences {
     popout_window_shortcut: Option<String>,
     #[serde(default)]
     popout_window_projectless_default_enabled: bool,
+    #[serde(default)]
+    friendly_task_titles_enabled: bool,
+    #[serde(default)]
+    friendly_task_title_model: Option<serde_json::Value>,
     #[serde(default = "default_quick_phrases")]
     quick_phrases: Vec<QuickPhrase>,
 }
@@ -718,6 +722,8 @@ impl Default for AppPreferences {
             appshots_play_sound: true,
             popout_window_shortcut: default_popout_window_shortcut(),
             popout_window_projectless_default_enabled: false,
+            friendly_task_titles_enabled: false,
+            friendly_task_title_model: None,
             quick_phrases: default_quick_phrases(),
         }
     }
@@ -773,6 +779,9 @@ struct AppPreferencesPatch {
     #[serde(default)]
     popout_window_shortcut: PatchField<String>,
     popout_window_projectless_default_enabled: Option<bool>,
+    friendly_task_titles_enabled: Option<bool>,
+    #[serde(default)]
+    friendly_task_title_model: PatchField<serde_json::Value>,
     quick_phrases: Option<Vec<QuickPhrase>>,
 }
 
@@ -1390,6 +1399,12 @@ fn update_app_preferences(
     if let Some(value) = patch.popout_window_projectless_default_enabled {
         preferences.popout_window_projectless_default_enabled = value;
     }
+    if let Some(value) = patch.friendly_task_titles_enabled {
+        preferences.friendly_task_titles_enabled = value;
+    }
+    if let PatchField::Value(value) = patch.friendly_task_title_model {
+        preferences.friendly_task_title_model = value;
+    }
     if let Some(value) = patch.quick_phrases {
         preferences.quick_phrases = value;
     }
@@ -1429,6 +1444,10 @@ struct AppPreferences {
     browser_download_directory: Option<String>,
     browser_ask_before_download: bool,
     appshots_play_sound: bool,
+    popout_window_shortcut: Option<String>,
+    popout_window_projectless_default_enabled: bool,
+    friendly_task_titles_enabled: bool,
+    friendly_task_title_model: Option<serde_json::Value>,
     quick_phrases: Vec<QuickPhrase>,
 }
 
@@ -1458,6 +1477,10 @@ struct AppPreferencesPatch {
     browser_download_directory: Option<String>,
     browser_ask_before_download: Option<bool>,
     appshots_play_sound: Option<bool>,
+    popout_window_shortcut: Option<String>,
+    popout_window_projectless_default_enabled: Option<bool>,
+    friendly_task_titles_enabled: Option<bool>,
+    friendly_task_title_model: Option<serde_json::Value>,
     quick_phrases: Option<Vec<QuickPhrase>>,
 }
 
@@ -1487,6 +1510,10 @@ fn get_app_preferences(_app: tauri::AppHandle) -> Result<AppPreferences, String>
         browser_download_directory: None,
         browser_ask_before_download: false,
         appshots_play_sound: true,
+        popout_window_shortcut: Some(default_popout_window_shortcut()),
+        popout_window_projectless_default_enabled: false,
+        friendly_task_titles_enabled: false,
+        friendly_task_title_model: None,
         quick_phrases: default_quick_phrases(),
     })
 }
@@ -1535,6 +1562,15 @@ fn update_app_preferences(
             .and_then(normalized_non_empty),
         browser_ask_before_download: patch.browser_ask_before_download.unwrap_or(false),
         appshots_play_sound: patch.appshots_play_sound.unwrap_or(true),
+        popout_window_shortcut: patch
+            .popout_window_shortcut
+            .and_then(normalized_non_empty)
+            .or_else(|| Some(default_popout_window_shortcut())),
+        popout_window_projectless_default_enabled: patch
+            .popout_window_projectless_default_enabled
+            .unwrap_or(false),
+        friendly_task_titles_enabled: patch.friendly_task_titles_enabled.unwrap_or(false),
+        friendly_task_title_model: patch.friendly_task_title_model,
         quick_phrases: patch.quick_phrases.unwrap_or_else(default_quick_phrases),
     })
 }
@@ -4771,8 +4807,9 @@ pub fn run() {
             #[cfg(desktop)]
             {
                 let preferences = read_app_preferences_impl(app.handle());
-                app.state::<NativeTelemetryState>()
-                    .configure(preferences.telemetry_consent_asked && preferences.telemetry_enabled);
+                app.state::<NativeTelemetryState>().configure(
+                    preferences.telemetry_consent_asked && preferences.telemetry_enabled,
+                );
             }
             #[cfg(desktop)]
             system_drag::setup(app.handle().clone());
diff --git a/wework/src/App.plugins.test.tsx b/wework/src/App.plugins.test.tsx
index a1c03102fa..75774a0ac1 100644
--- a/wework/src/App.plugins.test.tsx
+++ b/wework/src/App.plugins.test.tsx
@@ -873,7 +873,7 @@ describe('App plugins route', () => {
         connectedAt: '2026-07-15T00:00:00.000Z',
       })
     )
-    vi.mocked(fetch).mockImplementation(async input => {
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
       const url = String(input)
       if (url.endsWith('/users/me')) {
         return {
@@ -918,12 +918,13 @@ describe('App plugins route', () => {
       }
       throw new Error(`Unexpected request: ${url}`)
     })
+    vi.stubGlobal('fetch', fetchMock)
     window.history.pushState({}, '', '/sites')
 
     renderApp()
 
     expect(await screen.findByText('云端站点')).toBeInTheDocument()
-    expect(fetch).toHaveBeenCalledWith(
+    expect(fetchMock).toHaveBeenCalledWith(
       'http://127.0.0.1:9100/api/sites?app_type=web&offset=0&limit=20',
       expect.objectContaining({
         headers: expect.objectContaining({ Authorization: 'Bearer cloud-secret' }),
@@ -933,7 +934,7 @@ describe('App plugins route', () => {
     await createSiteFromMenu()
 
     await waitFor(() => expect(window.location.pathname).toBe('/'))
-    expect(fetch).toHaveBeenCalledWith(
+    expect(fetchMock).toHaveBeenCalledWith(
       'http://127.0.0.1:9100/api/plugins/builtin/wegent-sites/ensure-installed',
       expect.objectContaining({
         method: 'POST',
diff --git a/wework/src/api/deliveries.test.ts b/wework/src/api/deliveries.test.ts
index ed7addf95c..290a320d65 100644
--- a/wework/src/api/deliveries.test.ts
+++ b/wework/src/api/deliveries.test.ts
@@ -101,4 +101,21 @@ describe('createDeliveryApi task tracking', () => {
     })
     expect(patch).toHaveBeenCalledOnce()
   })
+
+  test('synchronizes a friendly runtime title to the bound task', async () => {
+    const renamedItem = { ...trackedItem, title: '修复登录回调', version: 2 }
+    const context = { loop_item_id: trackedItem.id } as CloudTaskContext
+    const get = vi.fn().mockResolvedValueOnce(context).mockResolvedValueOnce(trackedItem)
+    const patch = vi.fn().mockResolvedValue(renamedItem)
+    const api = createDeliveryApi(clientWith({ get, patch }))
+
+    await expect(
+      api.updateTaskTrackingTitle({ deviceId: 'local-device', taskId: 'runtime-1' }, '修复登录回调')
+    ).resolves.toEqual(renamedItem)
+
+    expect(patch).toHaveBeenCalledWith('/v1/loop-items/WEG-1', {
+      version: 1,
+      title: '修复登录回调',
+    })
+  })
 })
diff --git a/wework/src/api/deliveries.ts b/wework/src/api/deliveries.ts
index f944ae37b1..4a2fe262b3 100644
--- a/wework/src/api/deliveries.ts
+++ b/wework/src/api/deliveries.ts
@@ -508,6 +508,26 @@ export function createDeliveryApi(client: HttpClient) {
           })
         : item
     },
+    async updateTaskTrackingTitle(
+      task: RuntimeTaskAddress,
+      title: string
+    ): Promise<CloudLoopItem | null> {
+      let context: CloudTaskContext
+      try {
+        context = await api.findCloudContextForTask(task)
+      } catch (error) {
+        if (error instanceof ApiError && error.status === 404) return null
+        throw error
+      }
+      if (!context.loop_item_id) return null
+      const item = await api.getLoopItem(context.loop_item_id)
+      return item.title === title
+        ? item
+        : api.updateLoopItem(item.id, {
+            version: item.version,
+            title,
+          })
+    },
     unbindCloudContext(task: RuntimeTaskAddress): Promise<void> {
       return client.delete('/v1/runtime-tasks/cloud-context', task)
     },
diff --git a/wework/src/api/hybrid/hybridServices.ts b/wework/src/api/hybrid/hybridServices.ts
index a54cb597ea..a013bdd6fd 100644
--- a/wework/src/api/hybrid/hybridServices.ts
+++ b/wework/src/api/hybrid/hybridServices.ts
@@ -1008,6 +1008,7 @@ function filterRuntimeChatStreamHandlers(
     onBlockCreated: route(handlers.onBlockCreated),
     onBlockUpdated: route(handlers.onBlockUpdated),
     onSubagentActivity: route(handlers.onSubagentActivity),
+    onRuntimeTaskTitleUpdated: route(handlers.onRuntimeTaskTitleUpdated),
     onRuntimeGoalUpdated: route(handlers.onRuntimeGoalUpdated),
     onRuntimeGoalCleared: route(handlers.onRuntimeGoalCleared),
     onRuntimeSupervisorUpdated: route(handlers.onRuntimeSupervisorUpdated),
diff --git a/wework/src/api/local/codexOfficialModels.ts b/wework/src/api/local/codexOfficialModels.ts
index 2e7d477cdf..9e03b36200 100644
--- a/wework/src/api/local/codexOfficialModels.ts
+++ b/wework/src/api/local/codexOfficialModels.ts
@@ -10,7 +10,7 @@ export async function requestLocalCodexOfficialModels(
   request: LocalExecutorRequest = requestLocalExecutor
 ): Promise<CodexOfficialModelList> {
   const response = await request<unknown>('runtime.codex.models.list', {
-    includeHidden: false,
+    includeHidden: true,
   })
   return normalizeCodexOfficialModelList(response)
 }
diff --git a/wework/src/api/local/localDelivery.test.ts b/wework/src/api/local/localDelivery.test.ts
index bba7ac60aa..ea5edecfbd 100644
--- a/wework/src/api/local/localDelivery.test.ts
+++ b/wework/src/api/local/localDelivery.test.ts
@@ -303,6 +303,7 @@ describe('local delivery API', () => {
           linked_at: '2026-07-27T00:00:00Z',
         }
       }
+      if (method === 'projects.list') return [projectRecord]
       if (method === 'todos.get') return taskRecord
       throw new Error(`Unexpected method: ${method}`)
     })
@@ -454,6 +455,40 @@ describe('local delivery API', () => {
     })
   })
 
+  test('synchronizes a friendly runtime title through executor IPC', async () => {
+    const renamedTask = { ...taskRecord, title: '修复登录回调', version: 2 }
+    const request = vi.fn(async (method: string) => {
+      if (method === 'runtime_tasks.context') {
+        return {
+          id: 'binding-1',
+          cloud_project_id: 'project-1',
+          loop_item_id: 'LOCAL-1',
+          task_user_id: 0,
+          device_id: 'local-device',
+          task_id: 'runtime-1',
+          task_title: 'Runtime task',
+          backend_task_id: null,
+          linked_at: '2026-07-27T00:00:00Z',
+        }
+      }
+      if (method === 'projects.list') return [projectRecord]
+      if (method === 'todos.get') return taskRecord
+      if (method === 'todos.update') return renamedTask
+      throw new Error(`Unexpected method: ${method}`)
+    })
+    const api = createLocalDeliveryApi(request)
+
+    await expect(
+      api.updateTaskTrackingTitle({ deviceId: 'local-device', taskId: 'runtime-1' }, '修复登录回调')
+    ).resolves.toMatchObject({ id: 'LOCAL-1', title: '修复登录回调' })
+
+    expect(request).toHaveBeenCalledWith('todos.update', {
+      project_id: 'project-1',
+      task_id: 'LOCAL-1',
+      todo: { version: 1, title: '修复登录回调' },
+    })
+  })
+
   test('routes local files, attachments, and deliveries through executor IPC', async () => {
     const delivery = {
       id: 'delivery-1',
diff --git a/wework/src/api/local/localDelivery.ts b/wework/src/api/local/localDelivery.ts
index 659fc9ac79..728337ae98 100644
--- a/wework/src/api/local/localDelivery.ts
+++ b/wework/src/api/local/localDelivery.ts
@@ -574,6 +574,22 @@ export function createLocalDeliveryApi(
         ? api.updateLoopItem(item.id, { version: item.version, status: nextStatus })
         : item
     },
+    async updateTaskTrackingTitle(task: RuntimeTaskAddress, title: string) {
+      let binding: LocalTaskBindingRecord
+      try {
+        binding = await request<LocalTaskBindingRecord>('runtime_tasks.context', {
+          device_id: task.deviceId,
+          task_id: task.taskId,
+        })
+      } catch {
+        return null
+      }
+      if (!binding.loop_item_id) return null
+      const item = await api.getLoopItem(binding.loop_item_id)
+      return item.title === title
+        ? item
+        : api.updateLoopItem(item.id, { version: item.version, title })
+    },
     async unbindCloudContext(task: RuntimeTaskAddress) {
       await request('runtime_tasks.unbind', {
         device_id: task.deviceId,
diff --git a/wework/src/api/local/localServices.test.ts b/wework/src/api/local/localServices.test.ts
index 7ac6f87277..5611fb53c0 100644
--- a/wework/src/api/local/localServices.test.ts
+++ b/wework/src/api/local/localServices.test.ts
@@ -90,6 +90,9 @@ describe('createLocalAppServices', () => {
     })
     const models = await services.modelApi.listModels()
 
+    expect(request).toHaveBeenCalledWith('runtime.codex.models.list', {
+      includeHidden: true,
+    })
     expect(models).toEqual({
       data: expect.arrayContaining([
         expect.objectContaining({
@@ -114,10 +117,18 @@ describe('createLocalAppServices', () => {
       ]),
     })
     const modelIds = models.data.map(model => model.modelId)
-    expect(modelIds).not.toContain('gpt-5.5')
-    expect(modelIds).not.toContain('Sol')
-    expect(modelIds).not.toContain('Terra')
-    expect(modelIds).not.toContain('Luna')
+    expect(modelIds).toEqual(
+      expect.arrayContaining([
+        'gpt-5.6-sol',
+        'gpt-5.6-terra',
+        'gpt-5.6-luna',
+        'gpt-5.5',
+        'gpt-5.4',
+        'gpt-5.4-mini',
+        'gpt-5.3-codex-spark',
+      ])
+    )
+    expect(modelIds).not.toContain('gpt-5.2')
     await expect(services.deviceApi.listDevices()).resolves.toEqual([
       expect.objectContaining({
         device_id: 'local-device',
diff --git a/wework/src/api/local/localServices.ts b/wework/src/api/local/localServices.ts
index 7a1883ba9b..0fb754d87b 100644
--- a/wework/src/api/local/localServices.ts
+++ b/wework/src/api/local/localServices.ts
@@ -1594,10 +1594,37 @@ async function createLocalRuntimeTaskPayload(
   const collaborationMode = runtimeCollaborationMode(normalizedData.modelOptions)
   const turnSeed = createRuntimeTurnSeed()
   const payload = { ...normalizedData } as Record<string, unknown>
+  const friendlyTitleExecutionRequest = normalizedData.friendlyTitle
+    ? buildLocalRuntimeExecutionRequest({
+        taskId: `friendly-title-${normalizedData.taskId ?? turnSeed}-${createRuntimeTurnSeed()}`,
+        runtime: 'codex',
+        teamId: normalizedData.teamId,
+        title: 'Generate friendly task title',
+        message: [
+          '为下面的用户请求生成一个简洁、具体、适合作为任务标题的中文标题。',
+          '只输出标题本身，不要引号、标点、解释或换行；最多 24 个汉字。',
+          '',
+          `用户请求：${normalizedData.message}`,
+        ].join('\n'),
+        turnSeed: createRuntimeTurnSeed(),
+        modelId: normalizedData.friendlyTitle.modelId,
+        modelType: normalizedData.friendlyTitle.modelType,
+        modelOptions: normalizedData.friendlyTitle.modelOptions,
+        cloudModelGateway,
+        localDeviceId,
+        workspacePath: runtimeWorkspace.workspacePath,
+        workspaceSource: runtimeWorkspace.workspaceSource,
+        branch: runtimeWorkspace.branch,
+        newSession: true,
+        ephemeral: true,
+        user,
+      })
+    : null
 
   return {
     ...payload,
     ...(collaborationMode ? { collaborationMode } : {}),
+    ...(friendlyTitleExecutionRequest ? { friendlyTitleExecutionRequest } : {}),
     title: runtimeTaskTitle(normalizedData),
     executionRequest: buildLocalRuntimeExecutionRequest({
       taskId: normalizedData.taskId,
@@ -2505,6 +2532,12 @@ export function createRuntimeWorkApiFromIpc(
       )
       debugLocalRuntimeCreatePayload(data, payload)
       const executionRequest = recordValue(payload.executionRequest)
+      console.info('[Wework] Friendly task title request', {
+        taskId: data.taskId,
+        enabled: Boolean(data.friendlyTitle),
+        executionRequestIncluded: Boolean(payload.friendlyTitleExecutionRequest),
+        modelId: data.friendlyTitle?.modelId ?? null,
+      })
       console.info('[Wework] Local runtime execution identity', {
         taskId: stringValue(executionRequest.task_id),
         userId: executionRequest.user_id ?? null,
diff --git a/wework/src/api/runtime/runtimeChatStream.ts b/wework/src/api/runtime/runtimeChatStream.ts
index 09e46c3b4d..29a7e5ba2b 100644
--- a/wework/src/api/runtime/runtimeChatStream.ts
+++ b/wework/src/api/runtime/runtimeChatStream.ts
@@ -186,6 +186,7 @@ function hasLocalExecutorResponseHandlers(handlers: ChatStreamHandlers): boolean
     handlers.onBlockCreated ||
     handlers.onBlockUpdated ||
     handlers.onSubagentActivity ||
+    handlers.onRuntimeTaskTitleUpdated ||
     handlers.onRuntimeGoalUpdated ||
     handlers.onRuntimeGoalCleared ||
     handlers.onRuntimeSupervisorUpdated ||
diff --git a/wework/src/components/layout/DesktopSidebar.test.tsx b/wework/src/components/layout/DesktopSidebar.test.tsx
index 22ef0bd522..11127c7592 100644
--- a/wework/src/components/layout/DesktopSidebar.test.tsx
+++ b/wework/src/components/layout/DesktopSidebar.test.tsx
@@ -1781,6 +1781,68 @@ describe('DesktopSidebar', () => {
     })
   })
 
+  test('sweeps a runtime task title after it is updated', async () => {
+    const chatPath = '/Users/alice/.wework/workspace/chats/2026-08-06/title-update'
+    const runtimeWork = (title: string) => ({
+      projects: [],
+      chats: [
+        {
+          deviceId: 'local-device',
+          deviceName: 'Local Mac',
+          deviceStatus: 'online' as const,
+          available: true,
+          workspacePath: chatPath,
+          workspaceKind: 'chat' as const,
+          tasks: [
+            {
+              taskId: 'friendly-title-task',
+              workspacePath: chatPath,
+              workspaceKind: 'chat' as const,
+              title,
+              runtime: 'codex' as const,
+            },
+          ],
+        },
+      ],
+      totalTasks: 1,
+    })
+    const lifecycleStore = new RuntimeTaskLifecycleStore('friendly-title-sheen-test')
+    const initialProps = createSidebarProps({
+      projects: [],
+      runtimeWork: runtimeWork('原始标题'),
+    })
+    lifecycleStore.syncRuntimeWork(initialProps.runtimeWork)
+    const { rerender } = render(
+      <RuntimeTaskLifecycleProvider store={lifecycleStore}>
+        <DesktopSidebar {...initialProps} />
+      </RuntimeTaskLifecycleProvider>
+    )
+
+    expect(screen.getByTestId('runtime-local-task-title-friendly-title-task')).not.toHaveClass(
+      'is-updated'
+    )
+
+    const updatedProps = createSidebarProps({
+      projects: [],
+      runtimeWork: runtimeWork('AI 优化后的标题'),
+    })
+    lifecycleStore.syncRuntimeWork(updatedProps.runtimeWork)
+    rerender(
+      <RuntimeTaskLifecycleProvider store={lifecycleStore}>
+        <DesktopSidebar {...updatedProps} />
+      </RuntimeTaskLifecycleProvider>
+    )
+
+    await waitFor(() => {
+      expect(screen.getByTestId('runtime-local-task-title-friendly-title-task')).toHaveClass(
+        'is-updated'
+      )
+    })
+    expect(
+      screen.getByTestId('runtime-local-task-title-shimmer-friendly-title-task')
+    ).toBeInTheDocument()
+  })
+
   test('removes pinned chat tasks from the task section without highlighted styling', () => {
     const chatPath = '/Users/alice/Documents/Codex/2026-07-12/pinned'
     renderSidebar({
@@ -4400,4 +4462,41 @@ describe('DesktopSidebar', () => {
     expect(button).toHaveTextContent('hello 20')
     expect(button).toHaveAttribute('aria-expanded', 'true')
   })
+
+  test('does not render a standalone task workspace as a project', () => {
+    const workspacePath = '/Users/alice/.wework/workspace/chats/standalone-task'
+
+    renderSidebar({
+      projects: [],
+      devices: [localDevice({ device_id: 'device-1', name: 'Local Mac' })],
+      standaloneDeviceId: 'device-1',
+      standaloneWorkspacePath: workspacePath,
+      runtimeWork: {
+        projects: [],
+        chats: [
+          {
+            deviceId: 'device-1',
+            deviceName: 'Local Mac',
+            deviceStatus: 'online',
+            available: true,
+            workspacePath,
+            workspaceKind: 'chat',
+            tasks: [
+              {
+                taskId: 'standalone-task',
+                workspacePath,
+                workspaceKind: 'chat',
+                title: '只显示在任务中',
+                runtime: 'codex',
+              },
+            ],
+          },
+        ],
+        totalTasks: 1,
+      },
+    })
+
+    expect(screen.queryByTestId('project-item-button')).not.toBeInTheDocument()
+    expect(screen.getByTestId('runtime-local-task-row-standalone-task')).toBeInTheDocument()
+  })
 })
diff --git a/wework/src/components/layout/DesktopSidebar.tsx b/wework/src/components/layout/DesktopSidebar.tsx
index fbafb205bb..1b4e084387 100644
--- a/wework/src/components/layout/DesktopSidebar.tsx
+++ b/wework/src/components/layout/DesktopSidebar.tsx
@@ -357,12 +357,14 @@ function runtimeWorkHasWorkspace(
   workspacePath: string
 ): boolean {
   const normalizedPath = normalizeSidebarWorkspacePath(workspacePath)
-  return (runtimeWork?.projects ?? []).some(projectWork =>
-    projectWork.deviceWorkspaces.some(
-      workspace =>
-        workspace.deviceId === deviceId &&
-        normalizeSidebarWorkspacePath(workspace.workspacePath) === normalizedPath
-    )
+  const hasMatchingWorkspace = (workspace: RuntimeDeviceWorkspace) =>
+    workspace.deviceId === deviceId &&
+    normalizeSidebarWorkspacePath(workspace.workspacePath) === normalizedPath
+
+  return (
+    (runtimeWork?.projects ?? []).some(projectWork =>
+      projectWork.deviceWorkspaces.some(hasMatchingWorkspace)
+    ) || (runtimeWork?.chats ?? []).some(hasMatchingWorkspace)
   )
 }
 
@@ -1438,6 +1440,9 @@ function RuntimeTaskRow({
   const [renameOpen, setRenameOpen] = useState(false)
   const [taskMenuPosition, setTaskMenuPosition] = useState<ProjectCreateMenuPosition | null>(null)
   const archiveDelayRef = useRef<number | null>(null)
+  const titleShimmerDelayRef = useRef<number | null>(null)
+  const previousTitleRef = useRef(task.title)
+  const [titleShimmering, setTitleShimmering] = useState(false)
   const worktreeTask = isRuntimeWorktreeTask(task)
   const workspaceTitle = getRuntimeTaskWorkspaceTitle(workspace)
   const projectLabel = projectName?.trim() || t('workbench.task')
@@ -1491,8 +1496,23 @@ function RuntimeTaskRow({
       if (archiveDelayRef.current !== null) {
         window.clearTimeout(archiveDelayRef.current)
       }
+      if (titleShimmerDelayRef.current !== null) {
+        window.clearTimeout(titleShimmerDelayRef.current)
+      }
     }
   }, [])
+  useEffect(() => {
+    if (previousTitleRef.current === task.title) return
+    previousTitleRef.current = task.title
+    setTitleShimmering(true)
+    if (titleShimmerDelayRef.current !== null) {
+      window.clearTimeout(titleShimmerDelayRef.current)
+    }
+    titleShimmerDelayRef.current = window.setTimeout(() => {
+      titleShimmerDelayRef.current = null
+      setTitleShimmering(false)
+    }, 760)
+  }, [task.title])
   const runArchive = async (options?: ArchiveRuntimeTaskOptions) => {
     setArchiving(true)
     try {
@@ -1624,7 +1644,20 @@ function RuntimeTaskRow({
         >
           {priorityLayout ? (
             <span className="flex min-w-0 flex-1 flex-col justify-center gap-0.5">
-              <span className="truncate">
+              <span
+                data-testid={`runtime-local-task-title-${task.taskId}`}
+                className={cn(
+                  'runtime-task-title relative truncate',
+                  titleShimmering && 'is-updated'
+                )}
+              >
+                {titleShimmering ? (
+                  <span
+                    aria-hidden="true"
+                    className="runtime-task-title-shimmer"
+                    data-testid={`runtime-local-task-title-shimmer-${task.taskId}`}
+                  />
+                ) : null}
                 <span
                   data-sidebar-drag-activator
                   data-testid={`runtime-local-task-drag-activator-${task.taskId}`}
@@ -1647,7 +1680,20 @@ function RuntimeTaskRow({
               </span>
             </span>
           ) : (
-            <span className="min-w-0 flex-1 truncate">
+            <span
+              data-testid={`runtime-local-task-title-${task.taskId}`}
+              className={cn(
+                'runtime-task-title relative min-w-0 flex-1 truncate',
+                titleShimmering && 'is-updated'
+              )}
+            >
+              {titleShimmering ? (
+                <span
+                  aria-hidden="true"
+                  className="runtime-task-title-shimmer"
+                  data-testid={`runtime-local-task-title-shimmer-${task.taskId}`}
+                />
+              ) : null}
               <span
                 data-sidebar-drag-activator
                 data-testid={`runtime-local-task-drag-activator-${task.taskId}`}
diff --git a/wework/src/components/layout/DesktopWorkbenchMain.tsx b/wework/src/components/layout/DesktopWorkbenchMain.tsx
index 686c15600e..c7d96be6e8 100644
--- a/wework/src/components/layout/DesktopWorkbenchMain.tsx
+++ b/wework/src/components/layout/DesktopWorkbenchMain.tsx
@@ -913,6 +913,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     const api = projectSpaceApiFor(projectToBind)
     if (!api) return
     const bindingTaskTitle =
+      runtimeTaskTitle ||
       truncateRuntimeTaskTitle(pendingBinding?.description) ||
       t('workbench.untitled_task', '未命名任务')
     let active = true
@@ -951,6 +952,7 @@ const DesktopWorkbenchPane = memo(function DesktopWorkbenchPane({
     pendingCloudProject,
     pendingTodoItem,
     projectSpaceApiFor,
+    runtimeTaskTitle,
     setPendingCloudContext,
     t,
   ])
diff --git a/wework/src/components/settings/GeneralSettingsPage.tsx b/wework/src/components/settings/GeneralSettingsPage.tsx
index a19aac52a5..60067b9db8 100644
--- a/wework/src/components/settings/GeneralSettingsPage.tsx
+++ b/wework/src/components/settings/GeneralSettingsPage.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react'
+import { useContext, useEffect, useState } from 'react'
 import {
   Activity,
   Bell,
@@ -32,6 +32,9 @@ import {
 import { keybindingFromKeyboardEvent, normalizeKeybinding } from '@/lib/keybindings'
 import { getWegentUsageDisplay } from '@/api/wegentUsage'
 import { useOptionalCloudConnection } from '@/features/cloud-connection/useCloudConnection'
+import { WorkbenchContext } from '@/features/workbench/useWorkbench'
+import { selectedModelExecutionFields } from '@/features/workbench/runtimeModelSelection'
+import type { UnifiedModel } from '@/types/api'
 
 type BooleanPreferenceKey = {
   [Key in keyof AppPreferencesPatch]-?: AppPreferencesPatch[Key] extends boolean | undefined
@@ -60,6 +63,7 @@ interface TrayDisplayOption {
 export function GeneralSettingsPage() {
   const { t } = useTranslation('common')
   const cloudConnection = useOptionalCloudConnection()
+  const workbench = useContext(WorkbenchContext)
   const [preferences, setPreferences] = useState<AppPreferences>(defaultAppPreferences)
   const [cloudQuotaName, setCloudQuotaName] = useState<string | null>(null)
   const [loading, setLoading] = useState(true)
@@ -258,6 +262,46 @@ export function GeneralSettingsPage() {
     }
   }
 
+  const saveFriendlyTaskTitles = async (
+    enabled: boolean,
+    modelName = preferences.friendlyTaskTitleModel?.modelName ?? '',
+    modelType = preferences.friendlyTaskTitleModel?.modelType ?? null
+  ) => {
+    const selectedModel = workbench?.projectChat.models.find(
+      model => `${model.type}:${model.name}` === `${modelType ?? ''}:${modelName}`
+    )
+    const execution = selectedModel ? selectedModelExecutionFields(selectedModel, {}) : null
+    const patch: AppPreferencesPatch = {
+      friendlyTaskTitlesEnabled: enabled && Boolean(selectedModel),
+      friendlyTaskTitleModel: selectedModel
+        ? {
+            modelName: selectedModel.name,
+            modelType: selectedModel.type,
+            executionModelId: execution?.modelId ?? '',
+            executionModelType: execution?.modelType ?? null,
+            options: execution?.modelOptions,
+          }
+        : null,
+    }
+    const previousPreferences = preferences
+    setSaving(true)
+    setError(null)
+    try {
+      setPreferences(current => ({ ...current, ...patch }))
+      setPreferences(await updateAppPreferences(patch))
+    } catch (saveError) {
+      console.error('[Wework] Failed to update friendly task title preferences', saveError)
+      setPreferences(previousPreferences)
+      setError(t('workbench.general_settings_save_failed'))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  const friendlyTitleModel = preferences.friendlyTaskTitleModel
+  const friendlyTitleModelKey = `${friendlyTitleModel?.modelType ?? ''}:${friendlyTitleModel?.modelName ?? ''}`
+  const friendlyTitleModels = workbench?.projectChat.models ?? []
+
   return (
     <SettingsPage data-testid="general-settings-page">
       <SettingsPageHeader
@@ -360,6 +404,82 @@ export function GeneralSettingsPage() {
             label: t('workbench.general_settings_task_completion_notifications'),
             description: t('workbench.general_settings_task_completion_notifications_description'),
           })}
+          <SettingsRow
+            label={t('workbench.friendly_task_titles_title', '使用友好标题')}
+            description={t(
+              'workbench.friendly_task_titles_desc',
+              '创建任务后，用你选择的模型异步生成简洁标题。'
+            )}
+            className={GENERAL_ROW_CLASS_NAME}
+            labelClassName={GENERAL_ROW_LABEL_CLASS_NAME}
+            control={
+              <SettingsSwitch
+                data-testid="friendly-task-titles-toggle"
+                checked={preferences.friendlyTaskTitlesEnabled}
+                disabled={
+                  loading ||
+                  saving ||
+                  (!friendlyTitleModel?.modelName && !workbench?.projectChat.selectedModel)
+                }
+                onCheckedChange={checked => {
+                  void saveFriendlyTaskTitles(
+                    checked,
+                    friendlyTitleModel?.modelName ??
+                      workbench?.projectChat.selectedModel?.name ??
+                      '',
+                    friendlyTitleModel?.modelType ??
+                      workbench?.projectChat.selectedModel?.type ??
+                      null
+                  )
+                }}
+                aria-label={t('workbench.friendly_task_titles_title', '使用友好标题')}
+              />
+            }
+          />
+          {preferences.friendlyTaskTitlesEnabled && (
+            <div data-testid="friendly-task-title-model-row" className="px-4 pb-3">
+              <div className="ml-3 flex items-center justify-between gap-4 rounded-lg bg-muted/50 px-3 py-2.5 max-sm:ml-0 max-sm:flex-col max-sm:items-stretch">
+                <div className="min-w-0">
+                  <div className="text-xs font-medium text-text-primary">
+                    {t('workbench.friendly_task_titles_model', '标题模型')}
+                  </div>
+                  <p className="mt-0.5 text-xs text-text-secondary">
+                    {t(
+                      'workbench.friendly_task_titles_model_desc',
+                      '仅用于生成任务标题，不影响当前任务使用的模型。'
+                    )}
+                  </p>
+                </div>
+                <select
+                  data-testid="friendly-task-title-model-select"
+                  value={friendlyTitleModelKey}
+                  disabled={loading || saving}
+                  onChange={event => {
+                    const [modelType, ...nameParts] = event.target.value.split(':')
+                    const modelName = nameParts.join(':')
+                    void saveFriendlyTaskTitles(
+                      preferences.friendlyTaskTitlesEnabled && Boolean(modelName),
+                      modelName,
+                      modelName ? (modelType as UnifiedModel['type']) : null
+                    )
+                  }}
+                  className="h-8 w-full rounded-md border border-border bg-background px-2 text-sm text-text-primary md:w-[220px]"
+                >
+                  <option value="">
+                    {t('workbench.friendly_task_titles_model_empty', '请选择模型')}
+                  </option>
+                  {friendlyTitleModels.map(model => (
+                    <option
+                      key={`${model.type}:${model.name}`}
+                      value={`${model.type}:${model.name}`}
+                    >
+                      {model.displayName || model.name}
+                    </option>
+                  ))}
+                </select>
+              </div>
+            </div>
+          )}
           <SettingsRow
             label={
               <span className="flex items-center gap-2">
diff --git a/wework/src/components/settings/ModelSettingsPage.tsx b/wework/src/components/settings/ModelSettingsPage.tsx
index 4763ff0107..d47fd803d6 100644
--- a/wework/src/components/settings/ModelSettingsPage.tsx
+++ b/wework/src/components/settings/ModelSettingsPage.tsx
@@ -2385,7 +2385,6 @@ export function ModelSettingsPage({
           onOpenCloudSettings={onOpenCloudSettings}
         />
       </div>
-
       <div className="mt-8">
         <CodexAuthSettingsSection isConnected>
           {loading ? (
diff --git a/wework/src/features/model-settings/codexOfficialModels.test.ts b/wework/src/features/model-settings/codexOfficialModels.test.ts
index 74e7afc739..d31923ba9a 100644
--- a/wework/src/features/model-settings/codexOfficialModels.test.ts
+++ b/wework/src/features/model-settings/codexOfficialModels.test.ts
@@ -7,6 +7,7 @@ describe('codexOfficialModels', () => {
       providers: [
         {
           id: 'custom',
+          type: 'provider',
           data: [{ model: 'zeta' }, { model: 'alpha' }],
         },
         {
@@ -21,6 +22,7 @@ describe('codexOfficialModels', () => {
       'zeta',
       'alpha',
       'gpt-5.6-sol',
+      'gpt-5.5',
       'gpt-5.4',
     ])
   })
@@ -33,6 +35,7 @@ describe('codexOfficialModels', () => {
       'gpt-5.6-luna',
       'gpt-5.6-terra',
       'gpt-5.6-sol',
+      'gpt-5.5',
     ]
     const result = normalizeCodexOfficialModelList({
       providers: [
@@ -56,18 +59,36 @@ describe('codexOfficialModels', () => {
       'GPT 5.6 Sol',
       'GPT 5.6 Terra',
       'GPT 5.6 Luna',
+      'GPT 5.5',
       'GPT 5.4',
       'GPT 5.4 Mini',
       'GPT 5.3 Codex Spark',
     ])
   })
 
-  test('filters legacy Codex picker models that should not be selectable', () => {
+  test('matches the ChatGPT official picker instead of exposing every model/list entry', () => {
     const result = normalizeCodexOfficialModelList({
-      data: [{ model: 'gpt-5.6-sol' }, { model: 'gpt-5.5' }],
+      data: [
+        { model: 'gpt-5.2' },
+        { model: 'gpt-5.3-codex-spark' },
+        { model: 'gpt-5.4-mini' },
+        { model: 'gpt-5.4' },
+        { model: 'gpt-5.5' },
+        { model: 'gpt-5.6-luna' },
+        { model: 'gpt-5.6-terra' },
+        { model: 'gpt-5.6-sol' },
+      ],
     })
 
-    expect(result.models.map(model => model.modelId)).toEqual(['gpt-5.6-sol'])
+    expect(result.models.map(model => model.modelId)).toEqual([
+      'gpt-5.6-sol',
+      'gpt-5.6-terra',
+      'gpt-5.6-luna',
+      'gpt-5.5',
+      'gpt-5.4',
+      'gpt-5.4-mini',
+      'gpt-5.3-codex-spark',
+    ])
   })
 
   test('preserves the supported reasoning effort sequence advertised by Codex', () => {
diff --git a/wework/src/features/model-settings/codexOfficialModels.ts b/wework/src/features/model-settings/codexOfficialModels.ts
index 41afa6135e..ba766bbf53 100644
--- a/wework/src/features/model-settings/codexOfficialModels.ts
+++ b/wework/src/features/model-settings/codexOfficialModels.ts
@@ -38,12 +38,15 @@ const CODEX_PICKER_MODELS = [
   { modelId: 'gpt-5.6-sol', label: 'GPT 5.6 Sol' },
   { modelId: 'gpt-5.6-terra', label: 'GPT 5.6 Terra' },
   { modelId: 'gpt-5.6-luna', label: 'GPT 5.6 Luna' },
+  { modelId: 'gpt-5.5', label: 'GPT 5.5' },
   { modelId: 'gpt-5.4', label: 'GPT 5.4' },
   { modelId: 'gpt-5.4-mini', label: 'GPT 5.4 Mini' },
   { modelId: 'gpt-5.3-codex-spark', label: 'GPT 5.3 Codex Spark' },
 ] as const
 
-const LEGACY_CODEX_PICKER_MODEL_IDS = new Set(['gpt-5.5'])
+const CODEX_PICKER_MODEL_IDS: ReadonlySet<string> = new Set(
+  CODEX_PICKER_MODELS.map(model => model.modelId)
+)
 
 function recordValue(value: unknown): Record<string, unknown> {
   return value && typeof value === 'object' && !Array.isArray(value)
@@ -105,7 +108,6 @@ function normalizeOfficialModel(
   const record = recordValue(value)
   const modelId = stringValue(record.model) ?? stringValue(record.id)
   if (!modelId) return null
-  if (LEGACY_CODEX_PICKER_MODEL_IDS.has(normalizedModelId(modelId))) return null
   const providerId = stringValue(camelOrSnake(record, 'providerId', 'provider_id')) ?? provider?.id
   const providerName =
     stringValue(camelOrSnake(record, 'providerName', 'provider_name')) ??
@@ -148,6 +150,14 @@ function normalizeOfficialModel(
   }
 }
 
+function isVisibleCodexPickerModel(model: CodexOfficialModel | null): model is CodexOfficialModel {
+  return (
+    model !== null &&
+    (model.providerType === 'provider' ||
+      CODEX_PICKER_MODEL_IDS.has(normalizedModelId(model.modelId)))
+  )
+}
+
 function sortModels(models: CodexOfficialModel[]): CodexOfficialModel[] {
   return [...models].sort(
     (left, right) =>
@@ -173,7 +183,7 @@ function normalizeProvider(value: unknown): CodexOfficialModelProvider | null {
   const normalizedModels = sortModels(
     arrayValue(record.data)
       .map(model => normalizeOfficialModel(model, provider))
-      .filter((model): model is CodexOfficialModel => model !== null)
+      .filter(isVisibleCodexPickerModel)
   )
   return { ...provider, models: normalizedModels }
 }
@@ -200,7 +210,7 @@ export function normalizeCodexOfficialModelList(value: unknown): CodexOfficialMo
   const fallbackModels = sortModels(
     arrayValue(record.data)
       .map(model => normalizeOfficialModel(model, fallbackProvider))
-      .filter((model): model is CodexOfficialModel => model !== null)
+      .filter(isVisibleCodexPickerModel)
   )
   return {
     providers: fallbackModels.length > 0 ? [{ ...fallbackProvider, models: fallbackModels }] : [],
diff --git a/wework/src/features/workbench/WorkbenchProvider.test.tsx b/wework/src/features/workbench/WorkbenchProvider.test.tsx
index 3ac8f28759..3fac3ca22f 100644
--- a/wework/src/features/workbench/WorkbenchProvider.test.tsx
+++ b/wework/src/features/workbench/WorkbenchProvider.test.tsx
@@ -9347,6 +9347,7 @@ describe('WorkbenchProvider runtime tasks', () => {
       return vi.fn()
     })
     const updateTaskTrackingStatus = vi.fn().mockResolvedValue(null)
+    const updateTaskTrackingTitle = vi.fn().mockResolvedValue(null)
     const runtimeWorkApi = createRuntimeWorkApiMock({
       listRuntimeWork: vi.fn().mockResolvedValue(
         createRuntimeWork({
@@ -9385,7 +9386,7 @@ describe('WorkbenchProvider runtime tasks', () => {
         subscribe,
       } as unknown as WorkbenchServices['chatStream'],
       projectSpaceApis: {
-        local: { updateTaskTrackingStatus },
+        local: { updateTaskTrackingStatus, updateTaskTrackingTitle },
       } as unknown as WorkbenchServices['projectSpaceApis'],
     })
 
@@ -9421,6 +9422,21 @@ describe('WorkbenchProvider runtime tasks', () => {
         'succeeded'
       )
     )
+
+    act(() => {
+      streamHandlers.onRuntimeTaskTitleUpdated?.({
+        taskId: 'runtime-a',
+        subtaskId: 'friendly-title',
+        deviceId: 'device-1',
+        title: '修复登录回调',
+      })
+    })
+    await waitFor(() =>
+      expect(updateTaskTrackingTitle).toHaveBeenCalledWith(
+        expect.objectContaining({ deviceId: 'device-1', taskId: 'runtime-a' }),
+        '修复登录回调'
+      )
+    )
   })
 
   test('sends queued runtime messages when the task becomes idle', async () => {
diff --git a/wework/src/features/workbench/WorkbenchProvider.tsx b/wework/src/features/workbench/WorkbenchProvider.tsx
index e5f1aa2442..96082ad6e4 100644
--- a/wework/src/features/workbench/WorkbenchProvider.tsx
+++ b/wework/src/features/workbench/WorkbenchProvider.tsx
@@ -235,6 +235,7 @@ export function WorkbenchProvider({
   const lifecycleStore = useMemo(() => new RuntimeTaskLifecycleStore(user.id), [user.id])
   const lifecycleSnapshot = useRuntimeTaskLifecycleStoreSnapshot(lifecycleStore)
   const trackingStatusSignaturesRef = useRef(new Map<string, string>())
+  const trackingTitleSignaturesRef = useRef(new Map<string, string>())
   const [state, dispatch] = useReducer(workbenchReducer, initialWorkbenchState)
   const remoteProjectSyncSignatureRef = useRef('')
   const projectActivationSignatureRef = useRef('')
@@ -1481,6 +1482,29 @@ export function WorkbenchProvider({
       })
     })
   })
+  const syncRuntimeTaskTitle = useStableEvent((address: RuntimeTaskAddress, title: string) => {
+    const normalizedTitle = title.trim()
+    if (!normalizedTitle) return
+    const trackingApis = [
+      resolvedServices.projectSpaceApis?.local,
+      resolvedServices.projectSpaceApis?.cloud ?? resolvedServices.deliveryApi,
+    ].filter((api, index, values) => Boolean(api) && values.indexOf(api) === index)
+    if (!trackingApis.length) return
+    const key = `${address.deviceId}:${address.taskId}`
+    if (trackingTitleSignaturesRef.current.get(key) === normalizedTitle) return
+    trackingTitleSignaturesRef.current.set(key, normalizedTitle)
+    void Promise.allSettled(
+      trackingApis.map(api => api!.updateTaskTrackingTitle(address, normalizedTitle))
+    ).then(results => {
+      if (results.every(result => result.status === 'rejected')) {
+        trackingTitleSignaturesRef.current.delete(key)
+        console.warn('[Wework] Failed to synchronize project task title', {
+          address,
+          errors: results.map(result => (result.status === 'rejected' ? result.reason : null)),
+        })
+      }
+    })
+  })
   const updateCanonicalRuntimeContextUsage = useStableEvent(
     (address: RuntimeTaskAddress, usage: RuntimeContextUsage) => {
       const currentAddress =
@@ -1524,6 +1548,14 @@ export function WorkbenchProvider({
           },
           onContextUsageUpdated: updateCanonicalRuntimeContextUsage,
           onSubagentActivity: applyRuntimeConversationSubagentActivity,
+          onRuntimeTaskTitleUpdated: (address, payload) => {
+            dispatch({
+              type: 'runtime_task_title_updated',
+              address,
+              title: payload.title,
+            })
+            syncRuntimeTaskTitle(address, payload.title)
+          },
           onRuntimeGoalUpdated: (address, payload) => {
             const goal = payload.goal ?? null
             setRuntimeConversationGoal(address, goal)
@@ -1554,6 +1586,7 @@ export function WorkbenchProvider({
       refreshRuntimeWorkLists,
       resolvedServices.chatStream,
       settleCanonicalRuntimeGuidance,
+      syncRuntimeTaskTitle,
       updateCanonicalRuntimeContextUsage,
     ]
   )
diff --git a/wework/src/features/workbench/runtimePaneMessages.test.ts b/wework/src/features/workbench/runtimePaneMessages.test.ts
index b9773ee8aa..00cbe47773 100644
--- a/wework/src/features/workbench/runtimePaneMessages.test.ts
+++ b/wework/src/features/workbench/runtimePaneMessages.test.ts
@@ -160,6 +160,35 @@ describe('createRuntimeTaskStreamHandlers', () => {
     expect('messageId' in actions[0]).toBe(false)
   })
 
+  test('forwards an active task title change without refreshing runtime work', () => {
+    const address: RuntimeTaskAddress = {
+      deviceId: 'device-1',
+      taskId: 'runtime-task-1',
+    }
+    const onRefreshWorkLists = vi.fn()
+    const onRuntimeTaskTitleUpdated = vi.fn()
+    const handlers = createRuntimeTaskStreamHandlers(address, {
+      onMessageAction: vi.fn(),
+      onRefreshWorkLists,
+      onRuntimeTaskTitleUpdated,
+    })
+
+    handlers.onRuntimeTaskTitleUpdated?.({
+      taskId: 'runtime-task-1',
+      subtaskId: 'friendly-title-turn',
+      deviceId: 'device-1',
+      title: '测试标题生成功能',
+    })
+
+    expect(onRefreshWorkLists).not.toHaveBeenCalled()
+    expect(onRuntimeTaskTitleUpdated).toHaveBeenCalledWith({
+      taskId: 'runtime-task-1',
+      subtaskId: 'friendly-title-turn',
+      deviceId: 'device-1',
+      title: '测试标题生成功能',
+    })
+  })
+
   test('inserts an idle supervisor correction before its assistant turn starts', () => {
     const address: RuntimeTaskAddress = {
       deviceId: 'device-1',
diff --git a/wework/src/features/workbench/runtimePaneMessages.ts b/wework/src/features/workbench/runtimePaneMessages.ts
index 9e3bc2ec3a..7dde604976 100644
--- a/wework/src/features/workbench/runtimePaneMessages.ts
+++ b/wework/src/features/workbench/runtimePaneMessages.ts
@@ -12,6 +12,7 @@ import type {
   RuntimeGoalEventPayload,
   RuntimeGoalContinuationPayload,
   RuntimePlanEventPayload,
+  RuntimeTaskTitleUpdatedPayload,
   RuntimeGuidanceAppliedPayload,
   RuntimeMessagePresentationReference,
   RuntimeSubagentActivityPayload,
@@ -45,6 +46,7 @@ export interface RuntimeTaskStreamHandlers {
   onRefreshWorkLists?: () => void
   onContextUsageUpdated?: (usage: RuntimeContextUsage) => void
   onSubagentActivity?: (payload: RuntimeSubagentActivityPayload) => void
+  onRuntimeTaskTitleUpdated?: (payload: RuntimeTaskTitleUpdatedPayload) => void
   onRuntimeGoalUpdated?: (payload: RuntimeGoalEventPayload) => void
   onRuntimeGoalCleared?: (payload: RuntimeGoalEventPayload) => void
   onRuntimeSupervisorUpdated?: (payload: RuntimeSupervisorEventPayload) => void
@@ -74,6 +76,10 @@ export interface RuntimeConversationStreamHandlers {
     address: RuntimeTaskAddress,
     payload: RuntimeSubagentActivityPayload
   ) => void
+  onRuntimeTaskTitleUpdated?: (
+    address: RuntimeTaskAddress,
+    payload: RuntimeTaskTitleUpdatedPayload
+  ) => void
   onRuntimeGoalUpdated?: (address: RuntimeTaskAddress, payload: RuntimeGoalEventPayload) => void
   onRuntimeGoalCleared?: (address: RuntimeTaskAddress, payload: RuntimeGoalEventPayload) => void
   onRuntimeSupervisorUpdated?: (
@@ -121,6 +127,7 @@ export function createRuntimeConversationStreamHandlers(
       onRefreshWorkLists: () => handlers.onRefreshWorkLists?.(address),
       onContextUsageUpdated: usage => handlers.onContextUsageUpdated?.(address, usage),
       onSubagentActivity: payload => handlers.onSubagentActivity?.(address, payload),
+      onRuntimeTaskTitleUpdated: payload => handlers.onRuntimeTaskTitleUpdated?.(address, payload),
       onRuntimeGoalUpdated: payload => handlers.onRuntimeGoalUpdated?.(address, payload),
       onRuntimeGoalCleared: payload => handlers.onRuntimeGoalCleared?.(address, payload),
       onRuntimeSupervisorUpdated: payload =>
@@ -141,6 +148,7 @@ export function createRuntimeConversationStreamHandlers(
     onBlockCreated: payload => resolve(payload)?.onBlockCreated?.(payload),
     onBlockUpdated: payload => resolve(payload)?.onBlockUpdated?.(payload),
     onSubagentActivity: payload => resolve(payload)?.onSubagentActivity?.(payload),
+    onRuntimeTaskTitleUpdated: payload => resolve(payload)?.onRuntimeTaskTitleUpdated?.(payload),
     onRuntimeGoalUpdated: payload => resolve(payload)?.onRuntimeGoalUpdated?.(payload),
     onRuntimeGoalCleared: payload => resolve(payload)?.onRuntimeGoalCleared?.(payload),
     onRuntimeSupervisorUpdated: payload => resolve(payload)?.onRuntimeSupervisorUpdated?.(payload),
@@ -447,6 +455,10 @@ export function createRuntimeTaskStreamHandlers(
       })
       handlers.onSubagentActivity?.(payload)
     },
+    onRuntimeTaskTitleUpdated: payload => {
+      if (!isRuntimeTaskStreamPayload(address, payload)) return
+      handlers.onRuntimeTaskTitleUpdated?.(payload)
+    },
     onRuntimeGoalUpdated: payload => {
       if (!isRuntimeTaskStreamPayload(address, payload)) return
       handlers.onRuntimeGoalUpdated?.(payload)
diff --git a/wework/src/features/workbench/useWorkbenchRuntimeMessaging.ts b/wework/src/features/workbench/useWorkbenchRuntimeMessaging.ts
index b4d61d35fb..e4bd820ff9 100644
--- a/wework/src/features/workbench/useWorkbenchRuntimeMessaging.ts
+++ b/wework/src/features/workbench/useWorkbenchRuntimeMessaging.ts
@@ -15,6 +15,7 @@ import { supportsGitWorktreeExecution } from '@/lib/projectClassification'
 import { localRuntimeAttachments, remoteAttachmentIds } from '@/lib/runtime-attachments'
 import { normalizeRuntimeWorkspacePath, runtimeProjectUiId } from '@/lib/runtime-project'
 import { notifyMainRuntimeWorkChanged } from '@/tauri/runtimeWorkSync'
+import { useAppPreferencesState } from '@/features/app-preferences/useAppPreferencesState'
 import {
   findWorkbenchDevice,
   getActiveWorkbenchDeviceId,
@@ -154,6 +155,8 @@ export function useWorkbenchRuntimeMessaging({
   refreshWorkLists,
   rememberExecutionDevice,
 }: UseWorkbenchRuntimeMessagingOptions) {
+  const appPreferences = useAppPreferencesState()
+  const preferences = appPreferences?.preferences
   const reportError = useCallback(
     (error: string, options?: RuntimePaneActionOptions) => {
       if (options?.onError) {
@@ -683,6 +686,17 @@ export function useWorkbenchRuntimeMessaging({
               options: selectedModelOptions,
             }
           : null,
+        ...(!options?.ephemeral &&
+        preferences?.friendlyTaskTitlesEnabled === true &&
+        preferences.friendlyTaskTitleModel
+          ? {
+              friendlyTitle: {
+                modelId: preferences.friendlyTaskTitleModel.executionModelId,
+                modelType: preferences.friendlyTaskTitleModel.executionModelType,
+                modelOptions: preferences.friendlyTaskTitleModel.options,
+              },
+            }
+          : {}),
         additionalSkills: payload.additional_skills ?? [],
         attachmentIds: payload.attachment_ids ?? [],
         attachments: payload.attachments ?? [],
@@ -938,6 +952,7 @@ export function useWorkbenchRuntimeMessaging({
     },
     [
       attachmentSelection,
+      preferences,
       dispatch,
       executorClient,
       lifecycleStore,
diff --git a/wework/src/features/workbench/workbenchReducer.test.ts b/wework/src/features/workbench/workbenchReducer.test.ts
index 96fd021f52..d659f79e91 100644
--- a/wework/src/features/workbench/workbenchReducer.test.ts
+++ b/wework/src/features/workbench/workbenchReducer.test.ts
@@ -102,6 +102,76 @@ describe('workbenchReducer', () => {
     expect(state.standaloneChatKey).toBe(4)
   })
 
+  test('updates only the matching runtime task title without changing its execution state', () => {
+    const state = {
+      ...initialWorkbenchState,
+      runtimeWork: {
+        projects: [
+          {
+            project: { id: 7, name: 'Repo' },
+            deviceWorkspaces: [
+              {
+                deviceId: 'device-1',
+                workspacePath: '/workspace/repo',
+                available: true,
+                mapped: true,
+                tasks: [
+                  {
+                    taskId: 'runtime-a',
+                    workspacePath: '/workspace/repo',
+                    title: '原始标题',
+                    runtime: 'codex' as const,
+                    status: 'succeeded',
+                    running: false,
+                    threadStatus: 'idle',
+                    turnStatus: 'completed' as const,
+                  },
+                  {
+                    taskId: 'runtime-b',
+                    workspacePath: '/workspace/repo',
+                    title: '不应变更',
+                    runtime: 'codex' as const,
+                    status: 'running',
+                    running: true,
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        chats: [],
+        totalTasks: 2,
+      },
+    }
+
+    const updated = workbenchReducer(state, {
+      type: 'runtime_task_title_updated',
+      address: {
+        deviceId: 'device-1',
+        workspacePath: '/workspace/repo',
+        taskId: 'runtime-a',
+      },
+      title: '优化后的标题',
+    })
+
+    expect(updated.runtimeWork?.projects[0].deviceWorkspaces[0].tasks).toEqual([
+      expect.objectContaining({
+        taskId: 'runtime-a',
+        title: '优化后的标题',
+        status: 'succeeded',
+        running: false,
+        threadStatus: 'idle',
+        turnStatus: 'completed',
+      }),
+      expect.objectContaining({
+        taskId: 'runtime-b',
+        title: '不应变更',
+        status: 'running',
+        running: true,
+      }),
+    ])
+  })
+
   test('preserves blank chat draft when returning to standalone chat', () => {
     const state = workbenchReducer(
       {
diff --git a/wework/src/features/workbench/workbenchReducer.ts b/wework/src/features/workbench/workbenchReducer.ts
index 7589589a3a..0e6fe9a23a 100644
--- a/wework/src/features/workbench/workbenchReducer.ts
+++ b/wework/src/features/workbench/workbenchReducer.ts
@@ -125,6 +125,11 @@ export type WorkbenchAction =
       type: 'runtime_task_optimistic_removed'
       address: RuntimeTaskAddress
     }
+  | {
+      type: 'runtime_task_title_updated'
+      address: RuntimeTaskAddress
+      title: string
+    }
   | { type: 'runtime_tasks_archived'; addresses: RuntimeTaskAddress[] }
   | { type: 'current_task_cleared' }
   | { type: 'error_set'; error: string | null }
@@ -173,6 +178,35 @@ function updateRuntimeWorkDeviceStatus(
   }
 }
 
+function updateRuntimeWorkTaskTitle(
+  runtimeWork: RuntimeWorkListResponse | null | undefined,
+  address: RuntimeTaskAddress,
+  title: string
+): RuntimeWorkListResponse | null {
+  if (!runtimeWork) return null
+
+  const updateWorkspace = (workspace: RuntimeDeviceWorkspace): RuntimeDeviceWorkspace => {
+    if (workspace.deviceId !== address.deviceId && workspace.remoteHostId !== address.deviceId) {
+      return workspace
+    }
+
+    const tasks = workspace.tasks.map(task =>
+      task.taskId === address.taskId ? { ...task, title } : task
+    )
+    if (tasks.every((task, index) => task === workspace.tasks[index])) return workspace
+    return { ...workspace, tasks }
+  }
+
+  return {
+    ...runtimeWork,
+    projects: runtimeWork.projects.map(project => ({
+      ...project,
+      deviceWorkspaces: project.deviceWorkspaces.map(updateWorkspace),
+    })),
+    chats: runtimeWork.chats.map(updateWorkspace),
+  }
+}
+
 function mergeRuntimeWorkPreservingTaskOrder(
   current: RuntimeWorkListResponse | null | undefined,
   next: RuntimeWorkListResponse | null
@@ -1170,6 +1204,11 @@ export function workbenchReducer(state: WorkbenchState, action: WorkbenchAction)
         ...state,
         runtimeWork: removeOptimisticRuntimeTask(state.runtimeWork, action.address),
       }
+    case 'runtime_task_title_updated':
+      return {
+        ...state,
+        runtimeWork: updateRuntimeWorkTaskTitle(state.runtimeWork, action.address, action.title),
+      }
     case 'runtime_tasks_archived':
       return {
         ...state,
diff --git a/wework/src/stream/chatStream.ts b/wework/src/stream/chatStream.ts
index 41fe7ed871..ad1025aaee 100644
--- a/wework/src/stream/chatStream.ts
+++ b/wework/src/stream/chatStream.ts
@@ -8,6 +8,7 @@ import type {
   RuntimeGoalEventPayload,
   RuntimeGoalContinuationPayload,
   RuntimePlanEventPayload,
+  RuntimeTaskTitleUpdatedPayload,
   RuntimeGuidanceAppliedPayload,
   RuntimeSubagentActivityPayload,
   RuntimeSupervisorEventPayload,
@@ -41,6 +42,7 @@ export interface ChatStreamHandlers {
   onBlockCreated?: (payload: ChatBlockCreatedPayload) => void
   onBlockUpdated?: (payload: ChatBlockUpdatedPayload) => void
   onSubagentActivity?: (payload: RuntimeSubagentActivityPayload) => void
+  onRuntimeTaskTitleUpdated?: (payload: RuntimeTaskTitleUpdatedPayload) => void
   onRuntimeGoalUpdated?: (payload: RuntimeGoalEventPayload) => void
   onRuntimeGoalCleared?: (payload: RuntimeGoalEventPayload) => void
   onRuntimeSupervisorUpdated?: (payload: RuntimeSupervisorEventPayload) => void
diff --git a/wework/src/stream/responseApiStream.test.ts b/wework/src/stream/responseApiStream.test.ts
index 0a8361d67e..bada0a1173 100644
--- a/wework/src/stream/responseApiStream.test.ts
+++ b/wework/src/stream/responseApiStream.test.ts
@@ -56,6 +56,29 @@ describe('emitResponseApiEvent', () => {
     })
   })
 
+  test('maps friendly task title updates', () => {
+    const onRuntimeTaskTitleUpdated = vi.fn()
+
+    emitResponseApiEvent(
+      { onRuntimeTaskTitleUpdated },
+      'runtime.task.title.updated',
+      {
+        taskId: 'task-1',
+        subtaskId: 'friendly-title-turn',
+        deviceId: 'device-1',
+        data: { title: '测试标题生成功能' },
+      },
+      createResponseApiStreamState()
+    )
+
+    expect(onRuntimeTaskTitleUpdated).toHaveBeenCalledWith({
+      taskId: 'task-1',
+      subtaskId: 'friendly-title-turn',
+      deviceId: 'device-1',
+      title: '测试标题生成功能',
+    })
+  })
+
   test('maps task supervisor state updates', () => {
     const onRuntimeSupervisorUpdated = vi.fn()
     const supervisor = {
diff --git a/wework/src/stream/responseApiStream.ts b/wework/src/stream/responseApiStream.ts
index e24b4b30bc..e4fb72ce65 100644
--- a/wework/src/stream/responseApiStream.ts
+++ b/wework/src/stream/responseApiStream.ts
@@ -4,6 +4,7 @@ import type {
   RuntimeGoal,
   RuntimeGoalContinuationPayload,
   RuntimeSupervisorState,
+  RuntimeTaskTitleUpdatedPayload,
   RuntimeTokenUsageBreakdown,
 } from '@/types/api'
 import type { ChatStreamHandlers } from './chatStream'
@@ -46,6 +47,7 @@ export const RESPONSE_API_STREAM_EVENTS = [
   'response.block.updated',
   'response.subagent.activity',
   'response.guidance.applied',
+  'runtime.task.title.updated',
   'runtime.goal.updated',
   'runtime.goal.cleared',
   'runtime.goal.continuation',
@@ -762,6 +764,16 @@ export function emitResponseApiEvent(
     return
   }
 
+  if (eventName === 'runtime.task.title.updated') {
+    const title = stringField(data, 'title')
+    if (!title) return
+    handlers.onRuntimeTaskTitleUpdated?.({
+      ...base,
+      title,
+    } as RuntimeTaskTitleUpdatedPayload)
+    return
+  }
+
   if (eventName === 'runtime.goal.updated') {
     handlers.onRuntimeGoalUpdated?.({
       ...base,
diff --git a/wework/src/styles/globals.css b/wework/src/styles/globals.css
index 610a61816f..c71a9518fe 100644
--- a/wework/src/styles/globals.css
+++ b/wework/src/styles/globals.css
@@ -130,6 +130,59 @@
   }
 }
 
+@keyframes runtime-task-title-sheen {
+  0% {
+    opacity: 0;
+    transform: translateX(-125%);
+  }
+
+  14%,
+  82% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+    transform: translateX(215%);
+  }
+}
+
+.runtime-task-title {
+  display: block;
+  isolation: isolate;
+  overflow: hidden;
+}
+
+.runtime-task-title-shimmer {
+  animation: runtime-task-title-sheen 760ms ease-out both;
+  background: linear-gradient(
+    105deg,
+    transparent,
+    rgb(var(--color-focus) / 0.12),
+    rgb(var(--color-focus) / 0.42),
+    rgb(255 255 255 / 0.34),
+    rgb(var(--color-focus) / 0.12),
+    transparent
+  );
+  inset: 0;
+  pointer-events: none;
+  position: absolute;
+  width: 54%;
+  z-index: 1;
+}
+
+.runtime-task-title > [data-sidebar-drag-activator] {
+  position: relative;
+  z-index: 2;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .runtime-task-title-shimmer {
+    animation: none;
+    opacity: 0;
+  }
+}
+
 .suffix-roll-out-up,
 .suffix-roll-in-up,
 .suffix-roll-out-down,
diff --git a/wework/src/tauri/appPreferences.test.ts b/wework/src/tauri/appPreferences.test.ts
index b90a9a6319..1cc55edcc8 100644
--- a/wework/src/tauri/appPreferences.test.ts
+++ b/wework/src/tauri/appPreferences.test.ts
@@ -36,6 +36,8 @@ const mergedDefaultPreferences = {
   appshotsPlaySound: true,
   popoutWindowShortcut: 'Alt+Shift+Space',
   popoutWindowProjectlessDefaultEnabled: false,
+  friendlyTaskTitlesEnabled: false,
+  friendlyTaskTitleModel: null,
   quickPhrases: [
     {
       id: 'default-summary-progress',
diff --git a/wework/src/tauri/appPreferences.ts b/wework/src/tauri/appPreferences.ts
index f004184ff5..81c2e52c45 100644
--- a/wework/src/tauri/appPreferences.ts
+++ b/wework/src/tauri/appPreferences.ts
@@ -1,5 +1,6 @@
 import { invoke } from '@tauri-apps/api/core'
 import { isTauriRuntime } from '@/lib/runtime-environment'
+import type { ModelSelectionConfig } from '@/types/api'
 
 export const DEFAULT_CONTEXT_COMPACTION_THRESHOLD = 85
 export const CONTEXT_COMPACTION_THRESHOLD_MIN = 1
@@ -37,9 +38,19 @@ export interface AppPreferences {
   appshotsPlaySound: boolean
   popoutWindowShortcut: string | null
   popoutWindowProjectlessDefaultEnabled: boolean
+  friendlyTaskTitlesEnabled: boolean
+  friendlyTaskTitleModel: FriendlyTaskTitleModelConfig | null
   quickPhrases: QuickPhrase[]
 }
 
+export interface FriendlyTaskTitleModelConfig {
+  modelName: string
+  modelType: ModelSelectionConfig['modelType']
+  executionModelId: string
+  executionModelType: ModelSelectionConfig['modelType']
+  options?: ModelSelectionConfig['options']
+}
+
 export type QuickPhraseMode = 'normal' | 'plan' | 'goal'
 
 export interface QuickPhrase {
@@ -96,6 +107,8 @@ export interface AppPreferencesPatch {
   appshotsPlaySound?: boolean
   popoutWindowShortcut?: string | null
   popoutWindowProjectlessDefaultEnabled?: boolean
+  friendlyTaskTitlesEnabled?: boolean
+  friendlyTaskTitleModel?: FriendlyTaskTitleModelConfig | null
   quickPhrases?: QuickPhrase[]
 }
 
@@ -145,6 +158,8 @@ export const defaultAppPreferences: AppPreferences = {
   appshotsPlaySound: true,
   popoutWindowShortcut: 'Alt+Shift+Space',
   popoutWindowProjectlessDefaultEnabled: false,
+  friendlyTaskTitlesEnabled: false,
+  friendlyTaskTitleModel: null,
   quickPhrases: defaultQuickPhrases,
 }
 
@@ -276,6 +291,11 @@ function mergeAppPreferences(value: unknown): AppPreferences {
       typeof record.popoutWindowProjectlessDefaultEnabled === 'boolean'
         ? record.popoutWindowProjectlessDefaultEnabled
         : defaultAppPreferences.popoutWindowProjectlessDefaultEnabled,
+    friendlyTaskTitlesEnabled:
+      typeof record.friendlyTaskTitlesEnabled === 'boolean'
+        ? record.friendlyTaskTitlesEnabled
+        : defaultAppPreferences.friendlyTaskTitlesEnabled,
+    friendlyTaskTitleModel: normalizeFriendlyTaskTitleModel(record.friendlyTaskTitleModel),
     quickPhrases: Array.isArray(record.quickPhrases)
       ? record.quickPhrases
           .flatMap(item => normalizeQuickPhrase(item))
@@ -284,6 +304,44 @@ function mergeAppPreferences(value: unknown): AppPreferences {
   }
 }
 
+function normalizeFriendlyTaskTitleModel(value: unknown): FriendlyTaskTitleModelConfig | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const record = value as Partial<FriendlyTaskTitleModelConfig>
+  const modelName = typeof record.modelName === 'string' ? record.modelName.trim() : ''
+  const executionModelId =
+    typeof record.executionModelId === 'string' ? record.executionModelId.trim() : ''
+  if (!modelName || !executionModelId) return null
+  const modelType =
+    record.modelType === 'public' ||
+    record.modelType === 'user' ||
+    record.modelType === 'group' ||
+    record.modelType === 'runtime'
+      ? record.modelType
+      : null
+  const executionModelType =
+    record.executionModelType === 'public' ||
+    record.executionModelType === 'user' ||
+    record.executionModelType === 'group' ||
+    record.executionModelType === 'runtime'
+      ? record.executionModelType
+      : null
+  const options =
+    record.options && typeof record.options === 'object' && !Array.isArray(record.options)
+      ? Object.fromEntries(
+          Object.entries(record.options).flatMap(([key, option]) =>
+            typeof option === 'string' ? [[key, option]] : []
+          )
+        )
+      : undefined
+  return {
+    modelName,
+    modelType,
+    executionModelId,
+    executionModelType,
+    ...(options ? { options } : {}),
+  }
+}
+
 function normalizeQuickPhrase(value: unknown): QuickPhrase[] {
   if (!value || typeof value !== 'object') return []
   const record = value as Partial<QuickPhrase>
diff --git a/wework/src/types/api.ts b/wework/src/types/api.ts
index defe85e895..9cef50dd84 100644
--- a/wework/src/types/api.ts
+++ b/wework/src/types/api.ts
@@ -1143,6 +1143,12 @@ export interface RuntimeTaskRenameRequest {
   title: string
 }
 
+export interface RuntimeTaskFriendlyTitleConfig {
+  modelId: string
+  modelType?: ModelType | null
+  modelOptions?: Record<string, string>
+}
+
 export interface RuntimeTaskCancelResponse {
   accepted: boolean
   taskId?: string
@@ -1168,6 +1174,7 @@ export interface RuntimeTaskCreateRequest {
   modelType?: ModelType | null
   modelOptions?: Record<string, string>
   modelSelection?: ModelSelectionConfig | null
+  friendlyTitle?: RuntimeTaskFriendlyTitleConfig | null
   additionalSkills?: SkillRef[]
   attachmentIds?: number[]
   attachments?: Attachment[]
@@ -2304,6 +2311,13 @@ export interface RuntimeGoalEventPayload {
   goal?: RuntimeGoal | null
 }
 
+export interface RuntimeTaskTitleUpdatedPayload {
+  taskId?: string
+  subtaskId?: string
+  deviceId?: string
+  title: string
+}
+
 export type RuntimeGoalContinuationStatus = 'started' | 'settled'
 
 export interface RuntimeGoalContinuationPayload {