chore: bump version to v3.11.1 and add release notes

The i18next t() calls for proxy.takeover.enabled/disabled were missing
the `app` interpolation parameter, causing {{app}} placeholders in
translation strings to render literally instead of showing the app name.

.gitignore

@@ -23,3 +23,4 @@ nul
 flatpak/cc-switch.deb
 flatpak-build/
 flatpak-repo/
+.worktrees/

CHANGELOG.md

@@ -7,9 +7,212 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+---
+
+## [3.11.1] - 2026-02-28
+
+### Hotfix Release
+
+This release reverts the Partial Key-Field Merging architecture introduced in v3.11.0, restoring the proven "full config overwrite + Common Config Snippet" mechanism, and fixes several UI and platform compatibility issues.
+
+**Stats**: 8 commits | 52 files changed | +3,948 insertions | -1,411 deletions
+
+### Reverted
+
+- **Restore Full Config Overwrite + Common Config Snippet** (revert 992dda5c): Reverted the partial key-field merging refactoring from v3.11.0 due to critical issues — non-whitelisted custom fields were lost during provider switching, backfill permanently stripped non-key fields from the database, and the whitelist required constant maintenance. Restores full config snapshot write, Common Config Snippet UI and backend commands, and 6 frontend components/hooks
+
+### Changed
+
+- **Proxy Panel Layout**: Moved proxy on/off toggle from accordion header into panel content area, placed directly above app takeover options, ensuring users see takeover configuration immediately after enabling the proxy
+- **Manual Import for OpenCode/OpenClaw**: Removed auto-import on startup; empty state now shows an "Import Current Config" button, consistent with Claude/Codex/Gemini behavior
+
 ### Fixed
 
-- **Windows Home Dir Regression**: Prevent providers/settings “disappearing” after upgrading from v3.10.2 → v3.10.3 when `HOME` differs from the real user profile directory; restore default path resolution and auto-detect the v3.10.3 legacy database location.
+- **"Follow System" Theme Not Auto-Updating**: Delegated to Tauri's native theme tracking (`set_window_theme(None)`) so the WebView's `prefers-color-scheme` media query stays in sync with OS theme changes
+- **Compact Mode Cannot Exit**: Restored `flex-1` on `toolbarRef` so `useAutoCompact`'s exit condition triggers correctly based on available width instead of content width
+- **Proxy Takeover Toast Shows {{app}}**: Added missing `app` interpolation parameter to i18next `t()` calls for proxy takeover enabled/disabled messages
+- **Windows Protocol Handler Side Effects**: Disabled environment check and one-click install on Windows to prevent unintended protocol handler registration
+
+---
+
+## [3.11.0] - 2026-02-26
+
+### Feature Release
+
+This release introduces **OpenClaw** as the fifth supported application, a full **Session Manager** for browsing conversation history across all apps, an independent **Backup Management** panel, **Oh My OpenCode (OMO)** integration, and 50+ other features, fixes, and improvements across 147 commits.
+
+**Stats**: 147 commits | 274 files changed | +32,179 insertions | -5,467 deletions
+
+### Added
+
+#### OpenClaw Support (New Application)
+
+- **OpenClaw Integration**: Full management support for OpenClaw as the fifth application in CC Switch, including provider switching, configuration panels (Env / Tools / Agents Defaults), Workspace file management (HEARTBEAT / BOOTSTRAP / BOOT), daily memory files, and additive overlay mode
+- **OpenClaw Provider Presets**: 13+ built-in provider presets with brand icon and complete i18n (zh/en/ja)
+- **OpenClaw Form Fields**: Dedicated provider form with providerKey input, model allowlist auto-registration, and default model button
+- **OpenClaw Config Panels**: Env editor, Tools editor, and Agents Defaults editor backed by JSON5 read/write (`openclaw_config.rs`)
+
+#### Session Manager
+
+- **Session Manager**: Browse and search conversation history for Claude Code, Codex, Gemini CLI, OpenCode, and OpenClaw with table-of-contents navigation and in-session search
+- **Session App Filter**: Auto-filter sessions by current app when entering the session page
+- **Session Performance**: Parallel directory scanning and head-tail JSONL reading for faster session list loading
+
+#### Backup Management
+
+- **Backup Panel**: Independent backup management panel with configurable backup policy (max count, auto-cleanup) and backup rename support
+- **Periodic Backup**: Hourly automatic backup timer during runtime
+- **Pre-Migration Backup**: Automatic backup before database schema migrations with backfill warning
+- **Delete Backup**: Delete individual backup files with confirmation dialog
+- **Backup Time Fix**: Use local time instead of UTC for backup file names
+
+#### Oh My OpenCode (OMO)
+
+- **OMO Integration**: Full Oh My OpenCode config file management with agent model selection, category configuration, and recommended model fill
+- **OMO Slim**: Lightweight oh-my-opencode-slim mode support with OmoVariant parameterization
+- **OMO Cross-Exclusion**: Enforce OMO ↔ OMO Slim mutual exclusion at the database level
+
+#### Workspace
+
+- **Daily Memory Search**: Full-text search across daily memory files with date-sorted display
+- **Clickable Paths**: Directory paths in workspace panels are now clickable; renamed “Today's Note” to “Add Memory”
+- **Workspace Files Panel**: Manage bootstrap markdown files for OpenClaw (HEARTBEAT / BOOTSTRAP / BOOT types)
+
+#### Provider Presets
+
+- **AWS Bedrock**: Support for AKSK and API Key authentication modes (Claude and OpenCode)
+- **SSAI Code**: Partner provider preset across all five apps
+- **CrazyRouter**: Partner provider preset with custom icon
+- **AICoding**: Partner provider preset with i18n promotion text
+- **Bailian**: Renamed from Qwen Coder with new icon; updated domestic model providers to latest versions
+
+#### Proxy & Network
+
+- **Thinking Budget Rectifier**: New rectifier for thinking budget parameters with dedicated module (`thinking_budget_rectifier.rs`)
+- **WebDAV Auto Sync**: Automatic periodic sync with large file protection mechanism
+
+#### UI & UX
+
+- **Theme Animation**: Circular reveal animation when toggling between light and dark themes
+- **Claude Quick Toggles**: Quick toggle switches in the Claude config JSON editor for common settings
+- **Dynamic Endpoint Hint**: Context-aware hint text in endpoint input based on API format selection
+- **AppSwitcher Auto Compact**: Automatically collapse to compact mode based on available width, with smooth transition animation
+- **App Transition**: Fade-in/fade-out animation when switching between OpenClaw and other apps
+- **Silent Startup Conditional**: Show silent startup option only when launch-on-startup is enabled
+
+#### Settings & Environment
+
+- **First-Run Confirmation**: Confirmation dialogs for proxy and usage features on first use
+- **Local Proxy Toggle**: `enableLocalProxy` setting to control proxy UI visibility on the home page
+- **Environment Check**: More granular local environment detection (installed CLI tool versions, Volta path detection)
+
+#### Usage & Pricing
+
+- **Usage Dashboard Enhancement**: Auto-refresh control, robust formatting, and request log table improvements
+- **New Model Pricing**: Added pricing data for claude-opus-4-6 and gpt-5.3-codex with incremental data seeding
+
+### Changed
+
+#### Architecture
+
+- **Partial Key-Field Merging (⚠️ Breaking, reverted in v3.11.1)**: Provider switching now uses partial key-field merging instead of full config overwrite, preserving user's non-provider settings (plugins, MCP, permissions). The "Common Config Snippet" feature has been removed as it is no longer needed. Removes 6 frontend files and ~150 lines of backend dead code (#1098)
+- **Manual Import**: Replaced auto-import on startup with manual “Import Current Config” button in empty state, reducing ~47 lines of startup code
+- **OMO Variant Parameterization**: Eliminated ~250 lines of OMO/OMO Slim code duplication via `OmoVariant` struct with STANDARD/SLIM constants
+- **OMO Common Config Removal**: Removed the two-layer merge system for OMO common config (-1,733 lines across 21 files)
+
+#### Code Quality
+
+- **ProviderForm Decomposition**: Extracted ProviderForm.tsx from 2,227 lines to 1,526 lines by splitting into 5 focused modules (opencodeFormUtils, useOmoModelSource, useOpencodeFormState, useOmoDraftState, useOpenclawFormState)
+- **Shared MCP/Skills Components**: Extracted AppCountBar, AppToggleGroup, and ListItemRow shared components to eliminate duplication across MCP and Skills panels
+- **OpenClaw TanStack Query Migration**: Migrated Env, Tools, and AgentsDefaults panels from manual useState/useEffect to centralized TanStack Query hooks
+
+#### Settings Layout
+
+- **Proxy Tab**: Split Advanced tab into dedicated Proxy tab (local proxy, failover, rectifiers, global outbound proxy); moved pricing config to Usage dashboard as collapsible accordion. SettingsPage reduced from ~716 to ~426 lines with 5-tab layout: General | Proxy | Advanced | Usage | About
+- **Data Section Split**: Split data accordion into Import/Export and Cloud Sync sections for better discoverability
+
+#### Terminal & Config
+
+- **Unified Terminal Selection**: Consolidated terminal preference to global settings; added WezTerm support and terminal name mapping (iterm2 → iterm)
+- **OpenClaw Agents Panel**: Primary model field set to read-only; detailed model fields (context window, max tokens, reasoning, cost) moved to advanced options
+- **Claude Model Update**: Updated Claude model references from 4.5 to 4.6 across all provider presets
+
+### Fixed
+
+#### Critical
+
+- **Windows Home Dir Regression**: Restored default home directory resolution on Windows to prevent providers/settings “disappearing” when `HOME` env var differs from the real user profile directory (Git/MSYS environments); auto-detects v3.10.3 legacy database location
+- **Linux White Screen**: Disabled WebKitGTK hardware acceleration on AMD GPUs (Cezanne/Radeon Vega) to prevent EGL initialization failure causing blank screen on startup
+- **OpenAI Beta Parameter**: Stopped appending `?beta=true` to OpenAI Chat Completions endpoints, fixing request failures for Nvidia and other `apiFormat=”openai_chat”` providers
+- **Health Check Auth Mode**: Health check now respects provider's auth_mode setting instead of always using x-api-key header
+
+#### Provider & Preset
+
+- **OpenClaw /v1 Prefix**: Removed /v1 prefix from OpenClaw anthropic-messages presets to prevent double path (/v1/v1/messages) with Anthropic SDK auto-append
+- **Opus Pricing**: Corrected Opus pricing from $15/$75 to $5/$25 and upgraded model ID to claude-opus-4-6
+- **AIGoCode URLs**: Unified API base URL to https://api.aigocode.com across all apps; removed trailing /v1 suffix
+- **Zhipu GLM**: Removed outdated partner status from Claude, OpenCode, and OpenClaw presets
+- **API Key Visibility**: Restored API Key input field when creating new Claude providers (was incorrectly hidden for non-cloud_provider categories)
+
+#### OMO / OMO Slim
+
+- **OMO Slim Category Checks**: Added missing omo-slim category checks across add/form/mutation paths
+- **OMO Slim Cache Invalidation**: Invalidate OMO Slim query cache after provider mutations to prevent stale UI state
+- **OMO Recommended Models**: Synced agent/category recommended models with upstream sources; fixed provider/model format to pure model IDs
+- **OMO Fill Feedback**: Added toast feedback when “Fill Recommended” button silently fails
+- **OMO Last-Provider Restriction**: Removed last-provider deletion restriction for OMO/OMO Slim plugins
+- **OpenCode Model Validation**: Reject saving OpenCode providers without at least one configured model
+
+#### OpenClaw
+
+- **OpenClaw P0-P3 Fixes**: Fixed 25 missing i18n keys, replaced key={index} with stable crypto.randomUUID(), excluded openclaw from ProxyToggle/FailoverToggle, added deep link merge_additive_config(), unified serde(flatten) naming, added directory existence checks, removed dead code, added duplicate key validation
+- **OpenClaw Robustness**: Fixed EnvPanel visibleKeys using entry key names instead of array indices; added NaN guards; validated provider ID and model before import
+- **OpenClaw i18n Dedup**: Merged duplicate openclaw i18n keys to restore provider form translations
+
+#### Platform
+
+- **Window Flash**: Prevented window flicker on silent startup (Windows)
+- **Title Bar Theme**: Title bar now follows dark/light mode theme changes
+- **Skills Path Separator**: Fixed path separator matching for skill installation status on Windows (supports both `/` and `\`)
+- **WSL Conditional Compilation**: Added `#[cfg(target_os = “windows”)]` to WSL helper functions to eliminate dead_code warnings on non-Windows platforms
+
+#### UI
+
+- **Toolbar Clipping**: Removed toolbar height limit that was clipping AppSwitcher
+- **Update Badge**: Show update badge instead of green check when a newer version is available
+- **Session Button Visibility**: Only show Session Manager button for Claude and Codex apps
+- **Directory Spacing**: Added vertical spacing between directory setting sections
+- **Dark Mode Cards**: Unified SQL import/export card styling in dark mode
+- **OpenClaw Scroll**: Enabled scrolling for OpenClaw configuration panel content
+
+#### i18n & Localization
+
+- **Session Manager i18n**: Replaced hardcoded Chinese strings with i18n keys for relative time, role labels, and UI elements
+- **OpenClaw Default Model Label**: Renamed “Enable/Default” to “Set as Default / Current Default” with wider button
+- **Daily Memory Sort**: Sort daily memory files by filename date (YYYY-MM-DD.md) instead of modification time
+- **Backup Name i18n**: Use local time for backup file names
+
+#### Other
+
+- **Skill Doc URL**: Use actual branch from download_repo for documentation URL; switched from /tree/ to /blob/ pointing to SKILL.md
+- **OpenCode Install Detection**: Added install.sh priority paths (OPENCODE_INSTALL_DIR > XDG_BIN_DIR > ~/bin > ~/.opencode/bin) with path dedup and cross-platform executable candidates
+- **Provider Auto-Import**: Removed auto-import side effect from useProvidersQuery queryFn; users now trigger import manually via empty state button
+- **Manual Backup Validation**: Treat missing database file as error during manual backup to prevent false success toast
+
+### Performance
+
+- **Session Panel Loading**: Parallel directory scanning and head-tail JSONL reading for Codex, OpenClaw, and OpenCode session providers
+- **Query Cache Cleanup**: Removed unnecessary TanStack Query cache overhead for Tauri local IPC calls
+
+### Documentation
+
+- **Sponsors**: Added/updated SSSAiCode, Crazyrouter, AICoding, Right Code, and MiniMax sponsor entries across all README languages
+- **User Manual**: Added user manual documentation (#979)
+
+### Maintenance
+
+- **Pre-Release Cleanup**: Removed debug logs, fixed clippy warnings, added missing Japanese translations, and formatted code
+- **UI Exclusions**: Hidden MCP, Skills, proxy/pricing, stream check, and model test panels for OpenClaw where not applicable
 
 ---
 

README.md

@@ -2,7 +2,7 @@
 
 # All-in-One Assistant for Claude Code, Codex & Gemini CLI
 
-[![Version](https://img.shields.io/badge/version-3.10.2-blue.svg)](https://github.com/farion1231/cc-switch/releases)
+[![Version](https://img.shields.io/badge/version-3.11.1-blue.svg)](https://github.com/farion1231/cc-switch/releases)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://github.com/farion1231/cc-switch/releases)
 [![Built with Tauri](https://img.shields.io/badge/built%20with-Tauri%202-orange.svg)](https://tauri.app/)
 [![Downloads](https://img.shields.io/endpoint?url=https://api.pinstudios.net/api/badges/downloads/farion1231/cc-switch/total)](https://github.com/farion1231/cc-switch/releases/latest)
@@ -15,11 +15,11 @@ English | [中文](README_ZH.md) | [日本語](README_JA.md) | [Changelog](CHANG
 
 ## ❤️Sponsor
 
-[![MiniMax](assets/partners/banners/minimax-en.jpg)](https://bit.ly/3Nue8mA)
+[![MiniMax](assets/partners/banners/minimax-en.jpeg)](https://platform.minimax.io/subscribe/coding-plan?code=ClLhgxr2je&source=link)
 
-MiniMax M2.1 is an open-source, SOTA model built for real-world development and agentic workflows. It delivers top-tier performance on major coding benchmarks such as SWE, VIBE, and Multi-SWE. Powered by a 10B active / 230B total MoE architecture, M2.1 enables faster inference, easier deployment, and even local execution. It excels at coding, navigating digital environments, and handling long, multi-step tasks at scale.
+MiniMax-M2.5 is a SOTA large language model designed for real-world productivity. Trained in a diverse range of complex real-world digital working environments, M2.5 builds upon the coding expertise of M2.1 to extend into general office work, reaching fluency in generating and operating Word, Excel, and Powerpoint files, context switching between diverse software environments, and working across different agent and human teams. Scoring 80.2% on SWE-Bench Verified, 51.3% on Multi-SWE-Bench, and 76.3% on BrowseComp, M2.5 is also more token efficient than previous generations, having been trained to optimize its actions and output through planning.
 
-[Click](https://bit.ly/3Nue8mA) to get an exclusive 12% off the MiniMax Coding Plan!
+[Click](https://platform.minimax.io/subscribe/coding-plan?code=ClLhgxr2je&source=link) to get an exclusive 12% off the MiniMax Coding Plan!
 
 ---
 
@@ -60,6 +60,16 @@ Claude Code / Codex / Gemini official channels at 38% / 2% / 9% of original pric
 <td>Thanks to AICoding.sh for sponsoring this project! AICoding.sh — Global AI Model API Relay Service at Unbeatable Prices! Claude Code at 19% of original price, GPT at just 1%! Trusted by hundreds of enterprises for cost-effective AI services. Supports Claude Code, GPT, Gemini and major domestic models, with enterprise-grade high concurrency, fast invoicing, and 24/7 dedicated technical support. CC Switch users who register via <a href="https://aicoding.sh/i/CCSWITCH">this link</a> get 10% off their first top-up!</td>
 </tr>
 
+<tr>
+<td width="180"><a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch"><img src="assets/partners/logos/crazyrouter.jpg" alt="AICoding" width="150"></a></td>
+<td>Thanks to Crazyrouter for sponsoring this project! Crazyrouter is a high-performance AI API aggregation platform — one API key for 300+ models including Claude Code, Codex, Gemini CLI, and more. All models at 55% of official pricing with auto-failover, smart routing, and unlimited concurrency. Crazyrouter offers an exclusive deal for CC Switch users: register via <a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch">this link</a>  to get <strong>$2 free credit</strong> instantly, plus enter promo code `CCSWITCH` on your first top-up for an extra <strong>30% bonus credit</strong>! </td>
+</tr>
+
+<tr>
+<td width="180"><a href="https://www.sssaicode.com/register?ref=DCP0SM"><img src="assets/partners/logos/sssaicode.png" alt="SSSAiCode" width="150"></a></td>
+<td>Thanks to SSSAiCode for sponsoring this project! SSSAiCode is a stable and reliable API relay service, dedicated to providing stable, reliable, and affordable Claude and Codex model services, <strong>offering high cost-effective official Claude service at just ¥0.5/$ equivalent</strong>, supporting monthly and pay-as-you-go billing plans with same-day fast invoicing. SSSAiCode offers a special deal for CC Switch users: register via <a href="https://www.sssaicode.com/register?ref=DCP0SM">this link</a> to enjoy $10 extra credit on every top-up!</td>
+</tr>
+
 </table>
 
 ## Screenshots
@@ -70,7 +80,7 @@ Claude Code / Codex / Gemini official channels at 38% / 2% / 9% of original pric
 
 ## Features
 
-### Current Version: v3.10.2 | [Full Changelog](CHANGELOG.md) | [Release Notes](docs/release-note-v3.9.0-en.md)
+### Current Version: v3.11.1 | [Full Changelog](CHANGELOG.md) | [Release Notes](docs/release-note-v3.11.1-en.md)
 
 **v3.8.0 Major Update (2025-11-28)**
 
@@ -146,6 +156,7 @@ Claude Code / Codex / Gemini official channels at 38% / 2% / 9% of original pric
 **Core Capabilities**
 
 - **Provider Management**: One-click switching between Claude Code, Codex, and Gemini API configurations
+- **AWS Bedrock Support**: Built-in AWS Bedrock provider presets with AKSK and API Key authentication, cross-region inference support (global/us/eu/apac), covering Claude Code and OpenCode
 - **Speed Testing**: Measure API endpoint latency with visual quality indicators
 - **Import/Export**: Backup and restore configs with auto-rotation (keep 10 most recent)
 - **i18n Support**: Complete Chinese/English localization (UI, errors, tray)

README_JA.md

@@ -15,11 +15,11 @@
 
 ## ❤️スポンサー
 
-[![MiniMax](assets/partners/banners/minimax-en.jpg)](https://bit.ly/3Nue8mA)
+[![MiniMax](assets/partners/banners/minimax-en.jpeg)](https://platform.minimax.io/subscribe/coding-plan?code=ClLhgxr2je&source=link)
 
-MiniMax M2.1 は、実務開発とエージェントワークフロー向けに構築されたオープンソースの最先端モデルです。100 億のアクティブパラメータ / 2,300 億の総パラメータを持つ MoE アーキテクチャにより、高速な推論、簡単なデプロイ、ローカル実行にも対応します。SWE、VIBE、Multi-SWE などの主要コーディングベンチマークでトップクラスの性能を発揮し、コーディング、デジタル環境のナビゲーション、大規模な多段階タスクの処理に優れています。
+MiniMax-M2.5 は、実際の生産性向上のために設計された最先端の大規模言語モデルです。多様で複雑な実環境のデジタルワークスペースでトレーニングされた M2.5 は、M2.1 のコーディング能力をベースに一般的なオフィス業務へと拡張し、Word・Excel・PowerPoint ファイルの生成と操作、多様なソフトウェア環境間のコンテキスト切り替え、異なるエージェントや人間チーム間での協働を流暢にこなします。SWE-Bench Verified で 80.2%、Multi-SWE-Bench で 51.3%、BrowseComp で 76.3% を達成し、計画的な行動と出力の最適化トレーニングにより、前世代よりもトークン効率に優れています。
 
-[こちら](https://bit.ly/3Nue8mA)から MiniMax Coding Plan の限定 12% オフを入手！
+[こちら](https://platform.minimax.io/subscribe/coding-plan?code=ClLhgxr2je&source=link)から MiniMax Coding Plan の限定 12% オフを入手！
 
 ---
 
@@ -60,6 +60,16 @@ Claude Code / Codex / Gemini 公式チャンネルが最安で元価格の 38% /
 <td>AICoding.sh のご支援に感謝します！AICoding.sh —— グローバル AI モデル API 超お得な中継サービス！Claude Code 81% オフ、GPT 99% オフ！数百社の企業に高コストパフォーマンスの AI サービスを提供。Claude Code、GPT、Gemini および国内主要モデルに対応、エンタープライズ級の高同時接続、迅速な請求書発行、24 時間年中無休の専属テクニカルサポート。<a href="https://aicoding.sh/i/CCSWITCH">こちらのリンク</a>から登録した CC Switch ユーザーは、初回チャージ 10% オフ！</td>
 </tr>
 
+<tr>
+<td width="180"><a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch"><img src="assets/partners/logos/crazyrouter.jpg" alt="AICoding" width="150"></a></td>
+<td>Crazyrouter のご支援に感謝します！Crazyrouter は高性能 AI API アグリゲーションプラットフォームです。1 つの API キーで Claude Code、Codex、Gemini CLI など 300 以上のモデルにアクセス可能。全モデルが公式価格の 55% で利用でき、自動フェイルオーバー、スマートルーティング、無制限同時接続に対応。CC Switch ユーザー向けの限定特典：<a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch">こちらのリンク</a>から登録すると <strong>$2 の無料クレジット</strong> を即時進呈。さらに初回チャージ時にプロモコード `CCSWITCH` を入力すると <strong>30% のボーナスクレジット</strong> が追加されます！</td>
+</tr>
+
+<tr>
+<td width="180"><a href="https://www.sssaicode.com/register?ref=DCP0SM"><img src="assets/partners/logos/sssaicode.png" alt="SSSAiCode" width="150"></a></td>
+<td>SSSAiCode のご支援に感謝します！SSSAiCode は安定性と信頼性に優れた API 中継サービスで、安定的で信頼性が高く、手頃な価格の Claude・Codex モデルサービスを提供しています。<strong>高コストパフォーマンスの公式 Claude サービスを 0.5￥/$ 換算で提供</strong>、月額制・Paygo など多様な課金方式に対応し、当日の迅速な請求書発行をサポート。CC Switch ユーザー向けの特別特典：<a href="https://www.sssaicode.com/register?ref=DCP0SM">こちらのリンク</a>から登録すると、毎回のチャージで $10 の追加ボーナスを受けられます！</td>
+</tr>
+
 </table>
 
 ## スクリーンショット
@@ -146,6 +156,7 @@ Claude Code / Codex / Gemini 公式チャンネルが最安で元価格の 38% /
 **コア機能**
 
 - **プロバイダ管理**：Claude Code、Codex、Gemini の API 設定をワンクリックで切り替え
+- **AWS Bedrock 対応**：AWS Bedrock プロバイダプリセットを内蔵、AKSK および API Key 認証に対応、クロスリージョン推論（global/us/eu/apac）をサポート、Claude Code と OpenCode に対応
 - **速度テスト**：エンドポイント遅延を計測し、品質を可視化
 - **インポート/エクスポート**：設定をバックアップ・復元（最新 10 件を自動ローテーション）
 - **多言語対応**：UI/エラー/トレイを含む中国語・英語・日本語ローカライズ

README_ZH.md

@@ -17,7 +17,7 @@
 
 [![MiniMax](assets/partners/banners/minimax-zh.jpeg)](https://platform.minimaxi.com/subscribe/coding-plan?code=7kYF2VoaCn&source=link)
 
-MiniMax M2.x 系列模型是面向实际开发与智能体工作流打造的编码模型，M2.1 基于 100 亿激活 / 2300 亿总参的混合专家架构打造，推理更快、部署更便捷且支持本地运行，在 SWE、VIBE、Multi-SWE 等主流代码评测基准中均表现顶尖，擅长代码开发、数字环境适配及规模化处理长链路多步骤任务。
+MiniMax M2.5 在编程、工具调用与搜索、办公等核心生产力场景均达到或刷新行业 SOTA，拥有架构师级代码能力与高效任务拆解能力，推理速度较上一代提升 37%、token 消耗更优；100 token/s 连续工作一小时仅需 1 美金，让复杂 Agent 规模化部署经济可行，已在企业多职能场景深度落地，加速全民 Agent 时代到来。
 
 [点击](https://platform.minimaxi.com/subscribe/coding-plan?code=7kYF2VoaCn&source=link)即可领取 MiniMax Coding Plan 专属 88 折优惠！
 
@@ -61,6 +61,16 @@ Claude Code / Codex / Gemini 官方渠道低至 3.8 / 0.2 / 0.9 折，充值更
 <td>感谢 AICoding.sh 赞助了本项目！AICoding.sh —— 全球大模型 API 超值中转服务！Claude Code 1.9 折，GPT 0.1 折，已为数百家企业提供高性价比 AI 服务。支持 Claude Code、GPT、Gemini 及国内主流模型，企业级高并发、极速开票、7×24 专属技术支持，通过<a href="https://aicoding.sh/i/CCSWITCH">此链接</a> 注册的 CC Switch 用户，首充可享受九折优惠！</td>
 </tr>
 
+<tr>
+<td width="180"><a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch"><img src="assets/partners/logos/crazyrouter.jpg" alt="AICoding" width="150"></a></td>
+<td>感谢 Crazyrouter 赞助了本项目！Crazyrouter 是一个高性能 AI API 聚合平台——一个 API Key 即可访问 300+ 模型，包括 Claude Code、Codex、Gemini CLI 等。全部模型低至官方定价的 55%，支持自动故障转移、智能路由和无限并发。Crazyrouter 为 CC Switch 用户提供了专属优惠：通过<a href="https://crazyrouter.com/register?aff=OZcm&ref=cc-switch">此链接</a>注册即可获得 <strong>$2 免费额度</strong>，首次充值时输入优惠码 `CCSWITCH` 还可获得额外 <strong>30% 奖励额度</strong>！</td>
+</tr>
+
+<tr>
+<td width="180"><a href="https://www.sssaicode.com/register?ref=DCP0SM"><img src="assets/partners/logos/sssaicode.png" alt="SSSAiCode" width="150"></a></td>
+<td>感谢 SSSAiCode 赞助了本项目！SSSAiCode 是一家稳定可靠的API中转站，致力于提供稳定、可靠、平价的Claude、CodeX模型服务，<strong>提供高性价比折合0.5￥/$的官方Claude服务</strong>，支持包月、Paygo多种计费方式、支持当日快速开票，SSSAiCode为本软件的用户提供特别优惠，使用<a href="https://www.sssaicode.com/register?ref=DCP0SM">此链接</a>注册每次充值均可享受10$的额外奖励！</td>
+</tr>
+
 </table>
 
 ## 界面预览
@@ -147,6 +157,7 @@ Claude Code / Codex / Gemini 官方渠道低至 3.8 / 0.2 / 0.9 折，充值更
 **核心功能**
 
 - **供应商管理**：一键切换 Claude Code、Codex 与 Gemini 的 API 配置
+- **AWS Bedrock 支持**：内置 AWS Bedrock 供应商预设，支持 AKSK 和 API Key 两种认证方式，支持跨区域推理（global/us/eu/apac），覆盖 Claude Code 和 OpenCode
 - **速度测试**：测量 API 端点延迟，可视化连接质量指示器
 - **导入导出**：备份和恢复配置，自动轮换（保留最近 10 个）
 - **国际化支持**：完整的中英文本地化（UI、错误、托盘）

docs/release-note-v3.11.0-en.md

@@ -0,0 +1,302 @@
+# CC Switch v3.11.0
+
+> OpenClaw Support, Session Manager, Backup Management & 50+ Improvements
+
+**[中文版 →](release-note-v3.11.0-zh.md) | [日本語版 →](release-note-v3.11.0-ja.md)**
+
+---
+
+## Overview
+
+CC Switch v3.11.0 is a major update that adds full management support for **OpenClaw** as the fifth application, introduces a new **Session Manager** and **Backup Management** feature. Additionally, **Oh My OpenCode (OMO) integration**, the **partial key-field merging** architecture upgrade for provider switching, **settings page refactoring**, and many other improvements make the overall experience more polished.
+
+**Release Date**: 2026-02-26
+
+**Update Scale**: 147 commits | 274 files changed | +32,179 / -5,467 lines
+
+---
+
+## Highlights
+
+- **OpenClaw Support**: Fifth managed application with 13 provider presets, Env/Tools/AgentsDefaults config editors, and Workspace file management
+- **Session Manager**: Browse conversation history across all five apps with table-of-contents navigation and in-session search
+- **Backup Management**: Independent backup panel with configurable policies, periodic backups, and pre-migration auto-backup
+- **Oh My OpenCode Integration**: Full OMO config management with OMO Slim lightweight mode support
+- **Partial Key-Field Merging (⚠️ Breaking Change)**: Provider switching now only replaces provider-related fields, preserving all other settings; the "Common Config Snippet" feature has been removed
+- **Settings Page Refactoring**: 5-tab layout with ~40% code reduction
+- **6 New Provider Presets**: AWS Bedrock, SSAI Code, CrazyRouter, AICoding, and more
+- **Thinking Budget Rectifier**: Fine-grained thinking budget control
+- **Theme Switch Animation**: Circular reveal transition animation
+- **WebDAV Auto Sync**: Automatic sync with large file protection
+
+---
+
+## Main Features
+
+### OpenClaw Support (New Fifth App)
+
+Full management support for OpenClaw, the fifth managed application following Claude Code, Codex, Gemini CLI, and OpenCode.
+
+- **Provider Management**: Add, edit, switch, and delete OpenClaw providers with 13 built-in presets
+- **Config Editors**: Three dedicated panels for Env (environment variables), Tools, and AgentsDefaults
+- **Workspace Panel**: HEARTBEAT/BOOTSTRAP/BOOT file management and daily memory
+- **Additive Overlay Mode**: Support config overlay instead of overwrite
+- **Default Model Button**: One-click to fill recommended models; auto-register suggested models to allowlist when adding providers
+- **Brand & Interaction**: Dedicated brand icon, fade-in/fade-out transition animation when switching apps
+- **Deep Link Support**: Import OpenClaw provider configurations via URL
+- **Full Internationalization**: Complete Chinese/English/Japanese support
+
+### Session Manager
+
+A brand-new session manager to browse and search conversation history.
+
+- Browse conversation history across Claude Code, Codex, Gemini CLI, OpenCode, and OpenClaw (#867, thanks @TinsFox)
+- Table-of-contents navigation and in-session search
+- Auto-filter by current app when entering the session page
+- Parallel directory scanning + head-tail JSONL reading for optimized loading performance
+
+### Backup Management
+
+An independent backup management panel for better data safety.
+
+- Configurable backup policy: maximum backup count and auto-cleanup rules
+- Hourly automatic backup timer during runtime
+- Auto-backup before database schema migrations with backfill warning
+- Support backup rename and deletion (with confirmation dialog)
+- Backup filenames use local time for better clarity
+
+### Oh My OpenCode (OMO) Integration
+
+Full Oh My OpenCode config file management.
+
+- Agent model selection, category configuration, and recommended model fill (#972, thanks @yovinchen)
+- Improved agent model selection UX with lowercase key fix (#1004, thanks @yovinchen)
+- OMO Slim lightweight mode support
+- OMO ↔ OMO Slim mutual exclusion (enforced at database level)
+
+### Workspace
+
+- Full-text search across daily memory files, sorted by date
+- Clickable directory paths for quick file location access
+
+### Toolbar
+
+- AppSwitcher auto-collapses to compact mode based on available width
+- Smooth transition animation for compact mode toggle
+
+### Settings
+
+- First-use confirmation dialogs for proxy and usage features to prevent accidental operations
+- New `enableLocalProxy` switch to control proxy UI visibility on home page
+- More granular local environment checks: CLI tool version detection (#870, thanks @kv-chiu), Volta path detection (#969, thanks @myjustify)
+
+### Provider Presets
+
+- **AWS Bedrock**: Support for AKSK and API Key authentication modes (#1047, thanks @keithyt06)
+- **SSAI Code**: Partner preset across all five apps
+- **CrazyRouter**: Partner preset with dedicated icon
+- **AICoding**: Partner preset with i18n promotion text
+- Updated domestic model provider presets to latest versions
+- Renamed Qwen Coder to Bailian (#965, thanks @zhu-jl18)
+
+### Other New Features
+
+- **Thinking Budget Rectifier**: Fine-grained thinking budget allocation control (#1005, thanks @yovinchen)
+- **WebDAV Auto Sync**: Automatic sync with large file protection (#923, thanks @clx20000410; #1043, thanks @SaladDay)
+- **Theme Switch Animation**: Circular reveal transition for a smoother visual experience (#905, thanks @funnytime75)
+- **Claude Config Editor Quick Toggles**: Quick toggle switches for common settings (#1012, thanks @JIA-ss)
+- **Dynamic Endpoint Hint**: Context-aware hint text based on API format selection (#860, thanks @zhu-jl18)
+- **Usage Dashboard Enhancement**: Auto-refresh control and robust formatting (#942, thanks @yovinchen)
+- **New Pricing Data**: claude-opus-4-6 and gpt-5.3-codex (#943, thanks @yovinchen)
+- **Silent Startup Optimization**: Silent startup option only shown when launch-on-startup is enabled
+
+---
+
+## Architecture Improvements
+
+### Partial Key-Field Merging (⚠️ Breaking Change)
+
+Provider switching now uses partial key-field merging instead of full config overwrite (#1098).
+
+**Before**: Switching providers overwrote the entire `settings_config` to the live config file. This meant that any non-provider settings the user manually added to the live file (plugins, MCP config, permissions, etc.) would be lost on every switch. To work around this, previous versions offered a "Common Config Snippet" feature that let users define shared config to be merged on every switch.
+
+**After**: Switching providers now only replaces provider-related key-values (API keys, endpoints, models, etc.), leaving all other settings intact. The "Common Config Snippet" feature is therefore no longer needed and has been removed.
+
+**Impact & Migration**:
+- If you **didn't use** Common Config Snippets, this change is fully transparent — switching just works better now
+- If you **used** Common Config Snippets to preserve custom settings (MCP config, permissions, etc.), those settings are now automatically preserved during switches — no action needed
+- If you used Common Config Snippets for other purposes (e.g., injecting extra config on every switch), please manually add those settings to your live config file after upgrading
+
+This refactoring removed 6 frontend files (3 components + 3 hooks) and ~150 lines of backend dead code.
+
+### Manual Import Replaces Auto-Import
+
+Startup no longer auto-imports external configurations. Users now click "Import Current Config" manually, preventing accidental data overwrites.
+
+### OmoVariant Parameterization
+
+Eliminated ~250 lines of duplicated code in the OMO module via `OmoVariant` struct parameterization.
+
+### OMO Common Config Removal
+
+Removed the two-layer merge system, reducing ~1,733 lines of code and simplifying the architecture.
+
+### ProviderForm Decomposition
+
+Reduced ProviderForm component from 2,227 lines to 1,526 lines by extracting 5 independent modules (opencodeFormUtils, useOmoModelSource, useOpencodeFormState, useOmoDraftState, useOpenclawFormState), significantly improving maintainability.
+
+### Shared MCP/Skills Components
+
+Extracted AppCountBar, AppToggleGroup, and ListItemRow shared components to reduce duplication across MCP and Skills panels (#897, thanks @PeanutSplash).
+
+### Settings Page Refactoring
+
+Refactored settings page to a 5-tab layout (General | Proxy | Advanced | Usage | About), reducing SettingsPage code from ~716 to ~426 lines.
+
+### Other Improvements
+
+- Unified terminal selection via global settings with WezTerm support added
+- Updated Claude model references from 4.5 to 4.6
+
+---
+
+## Bug Fixes
+
+### Critical Fixes
+
+- **Windows Home Dir Regression**: Restored default home directory resolution to prevent providers/settings "disappearing" when `HOME` env var differs from the real user profile directory in Git/MSYS environments
+- **Linux White Screen**: Disabled WebKitGTK hardware acceleration on AMD GPUs (Cezanne/Radeon Vega) to prevent blank screen on startup (#986, thanks @ThendCN)
+- **OpenAI Beta Parameter**: Stopped appending `?beta=true` to `/v1/chat/completions` endpoints, fixing request failures for Nvidia and other `apiFormat="openai_chat"` providers (#1052, thanks @jnorthrup)
+- **Health Check Auth**: Health check now respects provider's `auth_mode` setting, preventing failures for proxy services that only support Bearer authentication (#824, thanks @Jassy930)
+
+### Provider Preset Fixes
+
+- Fixed OpenClaw `/v1` prefix causing double path (/v1/v1/messages)
+- Corrected Opus pricing ($15/$75 → $5/$25) and upgraded to 4.6
+- Unified AIGoCode URL to `https://api.aigocode.com` across all apps
+- Removed outdated partner status from Zhipu GLM presets
+- Restored API Key input visibility when creating new Claude providers
+- Hide quick toggles for non-active providers, show context-aware JSON editor hints
+
+### OMO Fixes
+
+- Added missing omo-slim category checks across add/form/mutation paths
+- Fixed OMO Slim query cache invalidation after provider mutations
+- Synced OMO agent/category recommended models with upstream sources
+- Added toast feedback for "Fill Recommended" button silent failures
+- Removed last-provider deletion restriction for OMO/OMO Slim
+- Reject saving OpenCode providers without configured models (#932, thanks @yovinchen)
+
+### OpenClaw Fixes
+
+- Fixed 25 missing i18n keys, replaced key={index} with stable IDs, added deep link additive merge, and other code review issues
+- Enhanced EnvPanel robustness (NaN guards, entry key names instead of array indices)
+- Merged duplicate i18n keys to restore provider form translations
+
+### Platform Fixes
+
+- Windows silent startup window flicker (#901, thanks @funnytime75)
+- Title bar dark mode theme following (#903, thanks @funnytime75)
+- Windows Skills path separator matching (#868, thanks @stmoonar)
+- WSL helper functions conditional compilation
+
+### UI Fixes
+
+- Toolbar height clipping causing AppSwitcher to be obscured
+- Show update badge instead of green checkmark when newer version available
+- Session Manager button only visible for Claude/Codex apps
+- Unified SQL import/export card dark mode styling (#1067, thanks @SaladDay)
+
+### Other Fixes
+
+- Replaced hardcoded Chinese strings in Session Manager with i18n keys
+- Fixed Skill documentation URL branch and path resolution (#977, thanks @yovinchen)
+- Added missing OpenCode install.sh installation path detection (#988, thanks @zhu-jl18)
+- Fixed Skill ZIP symlink resolution (#1040, thanks @yovinchen)
+- Added missing OpenCode checkbox in MCP add/edit form (#1026, thanks @yovinchen)
+- Removed auto-import side effect from useProvidersQuery queryFn
+
+---
+
+## Performance
+
+- Parallel directory scanning + head-tail JSONL reading for session panel, significantly improving session list loading speed
+- Removed unnecessary TanStack Query cache overhead for Tauri local IPC calls
+
+---
+
+## Documentation
+
+- Sponsor updates: SSSAiCode, Crazyrouter, AICoding, Right Code, MiniMax
+- Added user manual documentation (#979, thanks @yovinchen)
+
+---
+
+## Notes & Considerations
+
+- **OpenClaw is a newly supported app**: OpenClaw CLI must be installed first to use related features.
+- **⚠️ Common Config Snippet feature has been removed**: Since provider switching now uses partial key-field merging (only replacing API keys, endpoints, models, etc.), user's other settings are automatically preserved, making Common Config Snippets unnecessary. See the "Architecture Improvements" section above for migration details.
+- **Auto-import changed to manual**: External configurations are no longer auto-imported on startup. Click "Import Current Config" manually when needed.
+- **OMO and OMO Slim are mutually exclusive**: Only one can be active at a time. Switching to one automatically disables the other.
+- **Backup is enabled by default**: Automatic hourly backup during runtime. Adjust the policy in the Backup panel.
+
+---
+
+## Special Thanks
+
+Thanks to all contributors for their contributions to this release!
+
+@TinsFox @keithyt06 @kv-chiu @SaladDay @jnorthrup @JIA-ss @clx20000410 @ThendCN @yovinchen @zhu-jl18 @myjustify @funnytime75 @PeanutSplash @Jassy930 @stmoonar
+
+---
+
+## Download & Installation
+
+Visit [Releases](https://github.com/farion1231/cc-switch/releases/latest) to download the appropriate version.
+
+### System Requirements
+
+| System  | Minimum Version                 | Architecture                        |
+| ------- | ------------------------------- | ----------------------------------- |
+| Windows | Windows 10 or later             | x64                                 |
+| macOS   | macOS 10.15 (Catalina) or later | Intel (x64) / Apple Silicon (arm64) |
+| Linux   | See table below                 | x64                                 |
+
+### Windows
+
+| File                                     | Description                                          |
+| ---------------------------------------- | ---------------------------------------------------- |
+| `CC-Switch-v3.11.0-Windows.msi`          | **Recommended** - MSI installer with auto-update     |
+| `CC-Switch-v3.11.0-Windows-Portable.zip` | Portable version, extract and run, no registry write |
+
+### macOS
+
+| File                             | Description                                                          |
+| -------------------------------- | -------------------------------------------------------------------- |
+| `CC-Switch-v3.11.0-macOS.zip`    | **Recommended** - Extract and drag to Applications, Universal Binary |
+| `CC-Switch-v3.11.0-macOS.tar.gz` | For Homebrew installation and auto-update                            |
+
+> **Note**: Since the author doesn't have an Apple Developer account, you may see an "unidentified developer" warning on first launch. Please close it, then go to "System Settings" → "Privacy & Security" → click "Open Anyway", and it will open normally afterwards.
+
+### Homebrew (macOS)
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+Update:
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| Distribution                            | Recommended Format | Installation Method                                                    |
+| --------------------------------------- | ------------------ | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`             | `sudo dpkg -i CC-Switch-*.deb` or `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`             | `sudo rpm -i CC-Switch-*.rpm` or `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`             | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage`        | Add execute permission and run directly, or use AUR                    |
+| Other distributions / Unsure            | `.AppImage`        | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/release-note-v3.11.0-ja.md

@@ -0,0 +1,302 @@
+# CC Switch v3.11.0
+
+> OpenClaw サポート、セッションマネージャー、バックアップ管理と 50 以上の改善
+
+**[中文版 →](release-note-v3.11.0-zh.md) | [English →](release-note-v3.11.0-en.md)**
+
+---
+
+## 概要
+
+CC Switch v3.11.0 は大規模なアップデートです。5番目のアプリケーション **OpenClaw** の完全管理サポートを追加し、新しい**セッションマネージャー**と**バックアップ管理**機能を導入しました。さらに、**Oh My OpenCode (OMO) 統合**、プロバイダー切り替えの**部分キーフィールドマージ**アーキテクチャアップグレード、**設定ページのリファクタリング**など、多数の改善により全体的な体験がさらに向上しました。
+
+**リリース日**: 2026-02-26
+
+**更新規模**: 147 commits | 274 files changed | +32,179 / -5,467 lines
+
+---
+
+## ハイライト
+
+- **OpenClaw サポート**: 5番目の管理対象アプリ、13 のプロバイダープリセット、Env/Tools/AgentsDefaults 設定エディター、Workspace ファイル管理
+- **セッションマネージャー**: 5つのアプリの会話履歴を閲覧、目次ナビゲーションとセッション内検索
+- **バックアップ管理**: 独立バックアップパネル、設定可能なポリシー、定期バックアップ、マイグレーション前自動バックアップ
+- **Oh My OpenCode 統合**: 完全な OMO 設定管理、OMO Slim 軽量モードサポート
+- **部分キーフィールドマージ（⚠️ 破壊的変更）**: プロバイダー切り替え時にプロバイダー関連フィールドのみ置換し、その他の設定を保持；「共通設定スニペット」機能は削除されました
+- **設定ページリファクタリング**: 5タブレイアウト、コード量約 40% 削減
+- **6つの新プロバイダープリセット**: AWS Bedrock、SSAI Code、CrazyRouter、AICoding など
+- **Thinking Budget Rectifier**: より精密な thinking budget 制御
+- **テーマ切り替えアニメーション**: 円形リビール遷移アニメーション
+- **WebDAV 自動同期**: 自動同期と大容量ファイル保護
+
+---
+
+## 主な機能
+
+### OpenClaw サポート（新しい5番目のアプリ）
+
+Claude Code、Codex、Gemini CLI、OpenCode に続く5番目の管理対象アプリケーションとして OpenClaw の完全管理サポートを追加しました。
+
+- **プロバイダー管理**: OpenClaw プロバイダーの追加、編集、切り替え、削除、13 の内蔵プリセット
+- **設定エディター**: Env（環境変数）、Tools（ツール）、AgentsDefaults（エージェントデフォルト）の3つの専用パネル
+- **Workspace パネル**: HEARTBEAT/BOOTSTRAP/BOOT ファイル管理とデイリーメモリ
+- **Additive オーバーレイモード**: 上書きではなく設定の重ね合わせをサポート
+- **デフォルトモデルボタン**: ワンクリックで推奨モデルを入力、プロバイダー追加時に候補モデルを allowlist に自動登録
+- **ブランドとインタラクション**: 専用ブランドアイコン、アプリ切り替えフェード遷移アニメーション
+- **ディープリンクサポート**: URL 経由で OpenClaw プロバイダー設定をインポート
+- **完全な国際化**: 中/英/日 三言語完全対応
+
+### セッションマネージャー
+
+会話履歴を閲覧・検索できる新しいセッションマネージャーです。
+
+- Claude Code、Codex、Gemini CLI、OpenCode、OpenClaw の5つのアプリの会話履歴を閲覧（#867、@TinsFox に感謝）
+- 目次ナビゲーションとセッション内検索
+- セッションページに入ると現在のアプリで自動フィルター
+- 並列ディレクトリスキャン + ヘッドテール JSONL 読み取りで読み込みパフォーマンスを最適化
+
+### バックアップ管理
+
+データの安全性を高める独立バックアップ管理パネルです。
+
+- 設定可能なバックアップポリシー: 最大バックアップ数、自動クリーンアップルール
+- ランタイム中の1時間ごとの定期自動バックアップ
+- データベースマイグレーション前の自動バックアップ、バックフィル警告プロンプト
+- バックアップのリネームと削除をサポート（確認ダイアログ付き）
+- バックアップファイル名にローカルタイムを使用、より直感的に
+
+### Oh My OpenCode (OMO) 統合
+
+完全な Oh My OpenCode 設定ファイル管理です。
+
+- エージェントモデル選択、カテゴリ設定、推奨モデル入力（#972、@yovinchen に感謝）
+- エージェントモデル選択 UX の改善、lowercase key 問題の修正（#1004、@yovinchen に感謝）
+- OMO Slim 軽量モードサポート
+- OMO と OMO Slim の相互排他（データベースレベルで一貫性を保証）
+
+### ワークスペース
+
+- デイリーメモリファイルの全文検索、日付順ソート
+- ディレクトリパスがクリック可能に、ファイル位置をすばやく開く
+
+### ツールバー
+
+- AppSwitcher がウィンドウ幅に応じて自動的にコンパクトモードに折りたたみ
+- コンパクトモード切り替えのスムーズ遷移アニメーション
+
+### 設定
+
+- プロキシと使用量機能に初回使用確認ダイアログを追加、誤操作を防止
+- `enableLocalProxy` スイッチを追加、ホーム画面のプロキシ UI 表示を制御
+- より詳細なローカル環境チェック: CLI ツールバージョン検出（#870、@kv-chiu に感謝）、Volta パス検出（#969、@myjustify に感謝）
+
+### プロバイダープリセット
+
+- **AWS Bedrock**: AKSK と API Key の2種類の認証方式をサポート（#1047、@keithyt06 に感謝）
+- **SSAI Code**: パートナープリセット、5アプリ対応
+- **CrazyRouter**: パートナープリセットと専用アイコン
+- **AICoding**: パートナープリセットとプロモーションテキスト
+- 国内モデルプロバイダープリセットを最新版に更新
+- Qwen Coder を百炼 (Bailian) にリネーム（#965、@zhu-jl18 に感謝）
+
+### その他の新機能
+
+- **Thinking Budget Rectifier**: より精密な thinking budget 制御（#1005、@yovinchen に感謝）
+- **WebDAV 自動同期**: 自動同期設定と大容量ファイル保護（#923、@clx20000410 に感謝；#1043、@SaladDay に感謝）
+- **テーマ切り替えアニメーション**: 円形リビール遷移アニメーション（#905、@funnytime75 に感謝）
+- **Claude 設定エディタークイックトグル**: よく使う設定項目のクイック切り替え（#1012、@JIA-ss に感謝）
+- **動的エンドポイントヒント**: API フォーマット選択に基づく動的ヒントテキスト（#860、@zhu-jl18 に感謝）
+- **使用量ダッシュボード強化**: 自動更新、堅牢なフォーマット（#942、@yovinchen に感謝）
+- **新しい価格データ**: claude-opus-4-6 と gpt-5.3-codex（#943、@yovinchen に感謝）
+- **サイレント起動の最適化**: サイレント起動オプションは自動起動が有効な場合のみ表示
+
+---
+
+## アーキテクチャ改善
+
+### 部分キーフィールドマージ（⚠️ 破壊的変更）
+
+プロバイダー切り替えを完全な設定上書きから部分キーフィールドマージ戦略に変更しました（#1098）。
+
+**変更前**: プロバイダーを切り替えると、`settings_config` 全体がライブ設定ファイルに上書きされていました。つまり、ユーザーがライブファイルに手動で追加した非プロバイダー設定（プラグイン設定、MCP 設定、権限設定など）は、切り替えのたびに失われていました。この問題を補うため、以前のバージョンでは「共通設定スニペット」機能を提供し、毎回の切り替え時にマージされる共通設定を定義できました。
+
+**変更後**: プロバイダー切り替え時に、プロバイダー関連のキー値（API キー、エンドポイント、モデルなど）のみが置換され、その他の設定はそのまま保持されます。そのため「共通設定スニペット」機能は不要となり、削除されました。
+
+**影響と移行**:
+- 共通設定スニペットを**使用していなかった**場合、この変更は完全に透過的で、切り替え体験が向上するだけです
+- カスタム設定（MCP 設定、権限など）を保持するために共通設定スニペットを**使用していた**場合、それらの設定は切り替え時に自動的に保持されるようになり、追加の操作は不要です
+- 共通設定スニペットを他の目的（切り替え時に追加設定を注入するなど）で使用していた場合は、アップグレード後にライブ設定ファイルに手動で設定を追加してください
+
+このリファクタリングにより、フロントエンドファイル 6 つ（コンポーネント 3 つ + hooks 3 つ）と約 150 行のバックエンドデッドコードを削除しました。
+
+### 手動インポートに変更
+
+起動時の自動インポートを廃止し、手動の「現在の設定をインポート」ボタンに変更。意図しないユーザーデータの上書きを防止します。
+
+### OmoVariant パラメータ化
+
+`OmoVariant` 構造体によるパラメータ化で、OMO モジュールの約250行の重複コードを削除しました。
+
+### OMO 共通設定の削除
+
+2層マージシステムを削除し、約1,733行のコードを削減、アーキテクチャを簡素化しました。
+
+### ProviderForm 分割
+
+ProviderForm コンポーネントを2,227行から1,526行に削減し、5つの独立モジュール（opencodeFormUtils、useOmoModelSource、useOpencodeFormState、useOmoDraftState、useOpenclawFormState）に分離。保守性が大幅に向上しました。
+
+### MCP/Skills 共有コンポーネント
+
+AppCountBar、AppToggleGroup、ListItemRow などの共有コンポーネントを抽出し、MCP と Skills パネルの重複コードを削減（#897、@PeanutSplash に感謝）。
+
+### 設定ページリファクタリング
+
+設定ページを5タブレイアウト（一般 | プロキシ | 詳細 | 使用量 | 情報）にリファクタリング。SettingsPage のコードを約716行から約426行に削減しました。
+
+### その他の改善
+
+- ターミナル統一: グローバル設定でターミナル選択を統一、WezTerm サポートを追加
+- Claude モデル参照を 4.5 から 4.6 に更新
+
+---
+
+## バグ修正
+
+### 重大な修正
+
+- **Windows ホームディレクトリ回帰**: デフォルトのホームディレクトリ解決を復元し、Git/MSYS 環境でのデータベースパス変更によるデータ「消失」を防止
+- **Linux 白画面**: AMD GPU の WebKitGTK ハードウェアアクセラレーションを無効化し、一部の Linux システムの起動白画面問題を解決（#986、@ThendCN に感謝）
+- **OpenAI Beta パラメータ**: `/v1/chat/completions` に `?beta=true` を追加しないように修正、Nvidia など OpenAI Chat 形式を使用するプロバイダーのリクエスト失敗を修正（#1052、@jnorthrup に感謝）
+- **ヘルスチェック認証**: プロバイダーの `auth_mode` 設定を尊重し、Bearer 認証のみをサポートするプロキシサービスのヘルスチェック失敗を回避（#824、@Jassy930 に感謝）
+
+### プロバイダープリセット修正
+
+- OpenClaw `/v1` プレフィックスの二重パス問題を修正
+- Opus 価格修正（$15/$75 → $5/$25）と 4.6 へのアップグレード
+- AIGoCode URL を `https://api.aigocode.com` に統一
+- Zhipu GLM の古いパートナーステータスを削除
+- 新規 Claude プロバイダー作成時の API Key 入力フィールドの表示を復元
+- 非アクティブプロバイダーのクイックトグルを非表示、コンテキスト対応の JSON エディターヒントを表示
+
+### OMO 修正
+
+- omo-slim カテゴリチェックの補完（add/form/mutation パス）
+- OMO Slim プロバイダー変更後のクエリキャッシュ無効化を修正
+- OMO agent/category 推奨モデルをアップストリームソースと同期
+- 「推奨を入力」ボタン失敗時の toast フィードバックを追加
+- OMO/OMO Slim の最後のプロバイダー削除制限を撤廃
+- OpenCode でモデル未設定時の保存を拒否（#932、@yovinchen に感謝）
+
+### OpenClaw 修正
+
+- 25個の欠落 i18n キー、key={index} を安定 ID に置換、ディープリンク additive マージなどのコードレビュー問題を修正
+- EnvPanel 堅牢性強化（NaN ガード、配列インデックスではなくエントリーキー名を使用）
+- i18n 重複キーのマージ、プロバイダーフォーム翻訳を復元
+
+### プラットフォーム修正
+
+- Windows サイレント起動時のウィンドウフラッシュ（#901、@funnytime75 に感謝）
+- タイトルバーのダークモード追従（#903、@funnytime75 に感謝）
+- Windows の Skills パスセパレーターマッチング（#868、@stmoonar に感謝）
+- WSL ヘルパー関数の条件付きコンパイル
+
+### UI 修正
+
+- ツールバーの高さクリッピングによる AppSwitcher の遮蔽を修正
+- 新バージョンがある場合、緑のチェックマークではなく更新バッジを表示
+- セッションマネージャーボタンを Claude/Codex アプリでのみ表示
+- SQL インポート/エクスポートカードのダークモードスタイルを統一（#1067、@SaladDay に感謝）
+
+### その他の修正
+
+- セッションマネージャーのハードコードされた中国語文字列を i18n キーに置換
+- Skill ドキュメント URL のブランチとパスを修正（#977、@yovinchen に感謝）
+- OpenCode install.sh インストールパス検出の補完（#988、@zhu-jl18 に感謝）
+- Skill ZIP シンボリックリンク解決の修正（#1040、@yovinchen に感謝）
+- MCP フォームに OpenCode チェックボックスを追加（#1026、@yovinchen に感謝）
+- useProvidersQuery の自動インポート副作用を削除
+
+---
+
+## パフォーマンス最適化
+
+- セッションパネルの並列ディレクトリスキャン + ヘッドテール JSONL 読み取りで、セッションリスト読み込み速度を大幅向上
+- Tauri ローカル IPC の不要な query cache を削除し、メモリ使用量を削減
+
+---
+
+## ドキュメント
+
+- スポンサー更新: SSSAiCode、Crazyrouter、AICoding、Right Code、MiniMax
+- ユーザーマニュアルを追加（#979、@yovinchen に感謝）
+
+---
+
+## 注意事項
+
+- **OpenClaw は新しくサポートされたアプリです**: 関連機能を使用するには、先に OpenClaw CLI をインストールする必要があります。
+- **⚠️ 共通設定スニペット機能は削除されました**: プロバイダー切り替えが部分キーフィールドマージ（API キー、エンドポイント、モデルなどのみ置換）に変更されたため、ユーザーのその他の設定は自動的に保持され、共通設定スニペットは不要になりました。移行の詳細は上記「アーキテクチャ改善」セクションを参照してください。
+- **自動インポートは手動に変更されました**: 起動時に外部設定を自動インポートしなくなりました。必要に応じて「現在の設定をインポート」を手動でクリックしてください。
+- **OMO と OMO Slim は相互排他**: 同時に一つだけ有効にできます。切り替え時にもう一方は自動的に無効になります。
+- **バックアップ機能はデフォルトで有効**: ランタイム中に1時間ごとに自動バックアップします。バックアップパネルでポリシーを調整できます。
+
+---
+
+## 特別な感謝
+
+以下のコントリビューターの皆様、このリリースへの貢献に感謝します！
+
+@TinsFox @keithyt06 @kv-chiu @SaladDay @jnorthrup @JIA-ss @clx20000410 @ThendCN @yovinchen @zhu-jl18 @myjustify @funnytime75 @PeanutSplash @Jassy930 @stmoonar
+
+---
+
+## ダウンロードとインストール
+
+[Releases](https://github.com/farion1231/cc-switch/releases/latest) から適切なバージョンをダウンロードしてください。
+
+### システム要件
+
+| システム | 最小バージョン                   | アーキテクチャ                      |
+| -------- | -------------------------------- | ----------------------------------- |
+| Windows  | Windows 10 以降                  | x64                                 |
+| macOS    | macOS 10.15 (Catalina) 以降      | Intel (x64) / Apple Silicon (arm64) |
+| Linux    | 下表参照                         | x64                                 |
+
+### Windows
+
+| ファイル                                 | 説明                                                 |
+| ---------------------------------------- | ---------------------------------------------------- |
+| `CC-Switch-v3.11.0-Windows.msi`          | **推奨** - MSI インストーラー、自動更新対応          |
+| `CC-Switch-v3.11.0-Windows-Portable.zip` | ポータブル版、解凍して実行、レジストリ書き込みなし   |
+
+### macOS
+
+| ファイル                         | 説明                                                              |
+| -------------------------------- | ----------------------------------------------------------------- |
+| `CC-Switch-v3.11.0-macOS.zip`    | **推奨** - 解凍して Applications にドラッグ、Universal Binary     |
+| `CC-Switch-v3.11.0-macOS.tar.gz` | Homebrew インストールと自動更新用                                 |
+
+> **注意**: 作者が Apple Developer アカウントを持っていないため、初回起動時に「開発元を確認できません」という警告が表示される場合があります。一度閉じてから、「システム設定」→「プライバシーとセキュリティ」→「このまま開く」をクリックすると、その後は正常に開けます。
+
+### Homebrew (macOS)
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+更新：
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| ディストリビューション                  | 推奨形式    | インストール方法                                                       |
+| --------------------------------------- | ----------- | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`      | `sudo dpkg -i CC-Switch-*.deb` または `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`      | `sudo rpm -i CC-Switch-*.rpm` または `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`      | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage` | 実行権限を追加して直接実行、または AUR を使用                          |
+| その他のディストリビューション / 不明   | `.AppImage` | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/release-note-v3.11.0-zh.md

@@ -0,0 +1,302 @@
+# CC Switch v3.11.0
+
+> OpenClaw 支持、会话管理器、备份管理与 50+ 项改进
+
+**[English →](release-note-v3.11.0-en.md) | [日本語版 →](release-note-v3.11.0-ja.md)**
+
+---
+
+## 概览
+
+CC Switch v3.11.0 是一次大规模更新，新增第五个应用 **OpenClaw** 的完整管理支持，同时带来全新的**会话管理器**和**备份管理**功能。此外，**Oh My OpenCode (OMO) 集成**、供应商切换的**部分键值合并**架构升级、**设置页面重构**等多项改进使整体体验更加完善。
+
+**发布日期**：2026-02-26
+
+**更新规模**：147 commits | 274 files changed | +32,179 / -5,467 lines
+
+---
+
+## 重点内容
+
+- **OpenClaw 支持**：第五个受管理应用，含 13 个供应商预设、Env/Tools/AgentsDefaults 配置编辑器、Workspace 文件管理
+- **会话管理器**：浏览五个应用的历史会话，支持目录导航和会话内搜索
+- **备份管理**：独立备份面板，可配置策略、定时备份、迁移前自动备份
+- **Oh My OpenCode 集成**：完整 OMO 配置管理，支持 OMO Slim 轻量模式
+- **部分键值合并（⚠️ 破坏性变更）**：供应商切换改为仅替换供应商相关字段，保留用户的其余设置；"通用配置片段"功能因此移除
+- **设置页面重构**：5 标签页布局，代码量减少约 40%
+- **6 组新供应商预设**：AWS Bedrock、SSAI Code、CrazyRouter、AICoding 等
+- **Thinking Budget Rectifier**：代理矫正器，更精细的 thinking budget 控制
+- **主题切换动画**：圆形揭示过渡动画，视觉体验升级
+- **WebDAV 自动同步**：支持自动同步与大文件防护
+
+---
+
+## 主要功能
+
+### OpenClaw 支持（新增第五应用）
+
+CC Switch 新增对 OpenClaw 的完整管理支持，这是继 Claude Code、Codex、Gemini CLI、OpenCode 之后的第五个受管理应用。
+
+- **供应商管理**：新增、编辑、切换、删除 OpenClaw 供应商，含 13 个内置预设
+- **配置编辑器**：Env（环境变量）、Tools（工具）、AgentsDefaults（代理默认值）三个专属配置面板
+- **Workspace 面板**：支持 HEARTBEAT/BOOTSTRAP/BOOT 文件管理及每日记忆
+- **Additive 叠加模式**：支持配置叠加而非覆盖
+- **默认模型按钮**：一键填充推荐模型，添加供应商时自动将建议模型注册到 allowlist
+- **品牌与交互**：专属品牌图标、应用切换淡入淡出过渡动画
+- **深链接支持**：通过 URL 导入 OpenClaw 供应商配置
+- **完整国际化**：中/英/日三语全面支持
+
+### 会话管理器 Sessions
+
+全新的会话管理器，帮助你浏览和检索历史会话记录。
+
+- 支持浏览 Claude Code、Codex、Gemini CLI、OpenCode、OpenClaw 五个应用的历史会话（#867，感谢 @TinsFox）
+- 目录导航和会话内搜索
+- 进入会话页面时默认过滤为当前应用，快速定位
+- 并行目录扫描 + 头尾 JSONL 读取，优化加载性能
+
+### 备份管理 Backup
+
+独立的备份管理面板，让数据安全更有保障。
+
+- 可配置备份策略：最大备份数量、自动清理规则
+- 运行时每小时定期自动备份
+- 数据库迁移前自动备份，带回填警告提示
+- 支持备份重命名和删除（含确认对话框）
+- 备份文件名使用本地时间，更直观
+
+### Oh My OpenCode (OMO) 集成
+
+完整的 Oh My OpenCode 配置文件管理。
+
+- Agent 模型选择、Category 配置、推荐模型填充（#972，感谢 @yovinchen）
+- 改进 Agent 模型选择 UX，修复 lowercase key 问题（#1004，感谢 @yovinchen）
+- OMO Slim 轻量模式支持
+- OMO 与 OMO Slim 互斥切换（数据库层级强制保证一致性）
+
+### 工作空间 Workspace
+
+- 每日记忆文件全文搜索，按日期排序
+- 目录路径可点击跳转，快速打开文件位置
+
+### 工具栏 Toolbar
+
+- AppSwitcher 根据窗口宽度自动折叠为紧凑模式
+- 紧凑模式切换平滑过渡动画
+
+### 设置 Settings
+
+- 代理和用量功能新增首次使用确认对话框，避免误操作
+- 新增 `enableLocalProxy` 开关，控制主页代理 UI 显示
+- 更精细的本地环境检查：CLI 工具版本检测（#870，感谢 @kv-chiu）、Volta 路径检测（#969，感谢 @myjustify）
+
+### 供应商预设 Preset
+
+- **AWS Bedrock**：支持 AKSK 和 API Key 两种认证方式（#1047，感谢 @keithyt06）
+- **SSAI Code**：合作伙伴预设，覆盖五端
+- **CrazyRouter**：合作伙伴预设及专属图标
+- **AICoding**：合作伙伴预设及推广文案
+- 更新国内模型供应商预设至最新版本
+- Qwen Coder 重命名为百炼 (Bailian)（#965，感谢 @zhu-jl18）
+
+### 其他新功能
+
+- **Thinking Budget Rectifier**：代理矫正器，更精细地控制 thinking budget 分配（#1005，感谢 @yovinchen）
+- **WebDAV 自动同步**：支持自动同步配置，并增加大文件防护（#923，感谢 @clx20000410；#1043，感谢 @SaladDay）
+- **主题切换动画**：圆形揭示过渡动画，视觉体验更流畅（#905，感谢 @funnytime75）
+- **Claude 配置编辑器快速开关**：快速切换常用配置项（#1012，感谢 @JIA-ss）
+- **动态端点提示**：根据 API 格式选择动态显示端点提示文本（#860，感谢 @zhu-jl18）
+- **用量仪表盘增强**：自动刷新、更强健的数据格式化（#942，感谢 @yovinchen）
+- **新增定价数据**：claude-opus-4-6 和 gpt-5.3-codex（#943，感谢 @yovinchen）
+- **静默启动优化**：静默启动选项仅在开机启动开启时显示
+
+---
+
+## 架构改进
+
+### 部分键值合并（⚠️ 破坏性变更）
+
+供应商切换从全量配置覆写改为部分键值合并策略（#1098）。
+
+**变更前**：切换供应商时，整个 `settings_config` 会覆写到 live 配置文件。这意味着用户在 live 文件中手动添加的非供应商设置（插件配置、MCP 配置、权限设置等）会在每次切换时丢失。为了弥补这个问题，之前版本提供了"通用配置片段"功能，让用户定义每次切换时都会合并的公共配置。
+
+**变更后**：切换供应商时，仅替换供应商相关的键值（API Key、端点、模型等），用户的其余设置完整保留。因此"通用配置片段"功能不再需要，已被移除。
+
+**影响与迁移**：
+- 如果你之前**没有使用**通用配置片段功能，此变更对你完全透明，切换体验只会更好
+- 如果你之前**使用了**通用配置片段功能来保留自定义设置（如 MCP 配置、权限等），升级后这些设置会在切换时自动保留，无需额外操作
+- 如果你利用通用配置片段做其他用途（如在切换时注入额外配置），请在升级后手动将这些配置写入 live 配置文件中
+
+此次重构删除了 6 个前端文件（3 个组件 + 3 个 hooks）、约 150 行后端死代码。
+
+### 手动导入替代自动导入
+
+启动时不再自动导入外部配置，改为手动点击"导入当前配置"按钮，避免意外覆盖用户数据。
+
+### OMO Variant 参数化
+
+通过 `OmoVariant` 结构体参数化消除 OMO 模块约 250 行重复代码。
+
+### OMO 公共配置移除
+
+删除二层合并系统，减少约 1,733 行代码，简化架构。
+
+### ProviderForm 拆分
+
+ProviderForm 组件从 2,227 行减至 1,526 行，提取 5 个独立模块（opencodeFormUtils、useOmoModelSource、useOpencodeFormState、useOmoDraftState、useOpenclawFormState），可维护性显著提升。
+
+### MCP/Skills 共享组件
+
+提取 AppCountBar、AppToggleGroup、ListItemRow 等共享组件，减少 MCP 和 Skills 面板的重复代码（#897，感谢 @PeanutSplash）。
+
+### 设置页面重构
+
+设置页面重构为 5 标签页布局（通用 | 代理 | 高级 | 用量 | 关于），SettingsPage 代码从约 716 行减至约 426 行。
+
+### 其他改进
+
+- 终端统一：全局设置统一终端选择，新增 WezTerm 支持
+- Claude 模型引用从 4.5 更新到 4.6
+
+---
+
+## Bug 修复
+
+### 严重修复
+
+- **Windows 主目录回归**：恢复默认主目录解析，防止 Git/MSYS 环境下数据库路径变更导致数据"丢失"
+- **Linux 白屏**：禁用 AMD GPU 的 WebKitGTK 硬件加速，解决部分 Linux 系统启动白屏问题（#986，感谢 @ThendCN）
+- **OpenAI Beta 参数**：不再为 `/v1/chat/completions` 添加 `?beta=true`，修复 Nvidia 等使用 OpenAI Chat 格式的供应商请求失败（#1052，感谢 @jnorthrup）
+- **健康检查认证**：尊重供应商 `auth_mode` 设置，避免仅支持 Bearer 认证的代理服务健康检查失败（#824，感谢 @Jassy930）
+
+### 供应商预设修复
+
+- 修复 OpenClaw `/v1` 前缀双重路径问题
+- Opus 定价修正（$15/$75 → $5/$25）并升级到 4.6
+- AIGoCode URL 统一为 `https://api.aigocode.com`
+- Zhipu GLM 移除过时合作伙伴状态
+- 新建 Claude 供应商时 API Key 输入框可见性恢复
+- 非活跃供应商隐藏快速开关，显示上下文感知的 JSON 编辑器提示
+
+### OMO 修复
+
+- omo-slim 分类检查补齐（add/form/mutation 路径）
+- OMO Slim 供应商变更后正确失效查询缓存
+- OMO agent/category 推荐模型与上游源同步
+- "填充推荐"按钮失败时增加 toast 反馈
+- 移除 OMO/OMO Slim 最后一个供应商的删除限制
+- OpenCode 未配置模型时拒绝保存（#932，感谢 @yovinchen）
+
+### OpenClaw 修复
+
+- 修复 25 个缺失 i18n key、替换 key={index} 为稳定 ID、深链接 additive 合并等代码审查问题
+- EnvPanel 健壮性增强（NaN 守卫、使用条目键名而非数组索引）
+- i18n 重复键合并，恢复供应商表单翻译
+
+### 平台修复
+
+- Windows 静默启动时窗口闪烁（#901，感谢 @funnytime75）
+- 标题栏暗黑模式跟随主题（#903，感谢 @funnytime75）
+- Windows Skills 路径分隔符匹配（#868，感谢 @stmoonar）
+- WSL 辅助函数条件编译
+
+### UI 修复
+
+- 工具栏高度裁切导致 AppSwitcher 被遮挡
+- 有新版本时显示更新徽章而非绿色对勾
+- 仅 Claude/Codex 应用显示会话管理器按钮
+- SQL 导入/导出卡片暗黑模式样式统一（#1067，感谢 @SaladDay）
+
+### 其他修复
+
+- 会话管理器硬编码中文字符串替换为 i18n key
+- Skill 文档 URL 分支和路径修正（#977，感谢 @yovinchen）
+- OpenCode install.sh 安装路径检测补齐（#988，感谢 @zhu-jl18）
+- Skill ZIP 符号链接解析修复（#1040，感谢 @yovinchen）
+- MCP 表单补齐 OpenCode 复选框（#1026，感谢 @yovinchen）
+- useProvidersQuery 中自动导入副作用移除
+
+---
+
+## 性能优化
+
+- 会话面板并行目录扫描 + 头尾 JSONL 读取，大幅提升会话列表加载速度
+- 移除 Tauri 本地 IPC 不必要的 query cache，减少内存占用
+
+---
+
+## 文档
+
+- 赞助商更新：SSSAiCode、Crazyrouter、AICoding、Right Code、MiniMax
+- 新增用户手册（#979，感谢 @yovinchen）
+
+---
+
+## 说明与注意事项
+
+- **OpenClaw 为新支持的应用**：需要先安装 OpenClaw CLI 才能使用相关功能。
+- **⚠️ 通用配置片段功能已移除**：由于供应商切换改为部分键值合并（仅替换 API Key、端点、模型等字段），用户的其余设置会自动保留，"通用配置片段"功能不再需要。详见上方"架构改进"章节的迁移说明。
+- **自动导入已改为手动**：启动时不再自动导入外部配置，请在需要时手动点击"导入当前配置"。
+- **OMO 与 OMO Slim 互斥**：同一时间只能启用其中一个，切换时另一个会自动禁用。
+- **备份功能默认开启**：运行时每小时自动备份，可在备份面板调整策略。
+
+---
+
+## 特别感谢
+
+感谢以下贡献者为本版本做出的贡献！
+
+@TinsFox @keithyt06 @kv-chiu @SaladDay @jnorthrup @JIA-ss @clx20000410 @ThendCN @yovinchen @zhu-jl18 @myjustify @funnytime75 @PeanutSplash @Jassy930 @stmoonar
+
+---
+
+## 下载与安装
+
+访问 [Releases](https://github.com/farion1231/cc-switch/releases/latest) 下载对应版本。
+
+### 系统要求
+
+| 系统    | 最低版本                      | 架构                                |
+| ------- | ----------------------------- | ----------------------------------- |
+| Windows | Windows 10 及以上             | x64                                 |
+| macOS   | macOS 10.15 (Catalina) 及以上 | Intel (x64) / Apple Silicon (arm64) |
+| Linux   | 见下表                        | x64                                 |
+
+### Windows
+
+| 文件                                     | 说明                                |
+| ---------------------------------------- | ----------------------------------- |
+| `CC-Switch-v3.11.0-Windows.msi`          | **推荐** - MSI 安装包，支持自动更新 |
+| `CC-Switch-v3.11.0-Windows-Portable.zip` | 便携版，解压即用，不写入注册表      |
+
+### macOS
+
+| 文件                             | 说明                                                      |
+| -------------------------------- | --------------------------------------------------------- |
+| `CC-Switch-v3.11.0-macOS.zip`    | **推荐** - 解压后拖入 Applications 即可，Universal Binary |
+| `CC-Switch-v3.11.0-macOS.tar.gz` | 用于 Homebrew 安装和自动更新                              |
+
+> **注意**：由于作者没有苹果开发者账号，首次打开可能出现"未知开发者"警告，请先关闭，然后前往"系统设置" → "隐私与安全性" → 点击"仍要打开"，之后便可以正常打开
+
+### Homebrew（macOS）
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+更新：
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| 发行版                                  | 推荐格式    | 安装方式                                                               |
+| --------------------------------------- | ----------- | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`      | `sudo dpkg -i CC-Switch-*.deb` 或 `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`      | `sudo rpm -i CC-Switch-*.rpm` 或 `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`      | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage` | 添加执行权限后直接运行，或使用 AUR                                     |
+| 其他发行版 / 不确定                     | `.AppImage` | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/release-note-v3.11.1-en.md

@@ -0,0 +1,122 @@
+# CC Switch v3.11.1
+
+> Revert Partial Key-Field Merging, Restore Common Config Snippet & Bug Fixes
+
+**[中文版 →](release-note-v3.11.1-zh.md) | [日本語版 →](release-note-v3.11.1-ja.md)**
+
+---
+
+## Overview
+
+CC Switch v3.11.1 is a hotfix release that reverts the **Partial Key-Field Merging** architecture introduced in v3.11.0, restoring the proven "**full config overwrite + Common Config Snippet**" mechanism. It also includes several UI and platform compatibility fixes.
+
+**Release Date**: 2026-02-28
+
+**Update Scale**: 8 commits | 52 files changed | +3,948 / -1,411 lines
+
+---
+
+## Highlights
+
+- **Restore Full Config Overwrite + Common Config Snippet**: Reverted partial key-field merging due to critical data loss issues; restores full config snapshot write and Common Config Snippet UI
+- **Proxy Panel Improvements**: Proxy toggle moved into panel body for better discoverability of takeover options
+- **Theme & Compact Mode Fixes**: "Follow System" theme now auto-updates; compact mode exit works correctly
+- **Windows Compatibility**: Disabled env check and one-click install to prevent protocol handler side effects
+
+---
+
+## Reverted
+
+### Restore Full Config Overwrite + Common Config Snippet
+
+Reverted the partial key-field merging refactoring introduced in v3.11.0 (revert 992dda5c).
+
+**Why reverted**: The partial key-field merging approach had three critical issues:
+1. **Data loss on switch**: Non-whitelisted custom fields were silently dropped during provider switching
+2. **Permanent backfill stripping**: Backfill permanently removed non-key fields from the database, causing irreversible data loss
+3. **Maintenance burden**: The whitelist of "key fields" required constant maintenance as new config keys were added
+
+**What's restored**:
+- Full config snapshot write on provider switch (predictable, complete overwrite)
+- Common Config Snippet UI and backend commands
+- 6 frontend components/hooks (3 components + 3 hooks)
+
+**Migration**:
+- If you upgraded to v3.11.0 and your providers lost custom fields, re-import your config or manually re-add the missing fields
+- Common Config Snippet is available again — use it to define shared config that should persist across provider switches
+
+---
+
+## Changed
+
+- **Proxy Panel Layout**: Moved proxy on/off toggle from accordion header into panel content area, placed directly above app takeover options. This ensures users see takeover configuration immediately after enabling the proxy, avoiding the common mistake of enabling the proxy without configuring takeover
+- **Manual Import for OpenCode/OpenClaw**: Removed auto-import on startup; empty state now shows an "Import Current Config" button, consistent with Claude/Codex/Gemini behavior
+
+---
+
+## Fixed
+
+- **"Follow System" Theme Not Auto-Updating**: Delegated to Tauri's native theme tracking (`set_window_theme(None)`) so the WebView's `prefers-color-scheme` media query stays in sync with OS theme changes
+- **Compact Mode Cannot Exit**: Restored `flex-1` on `toolbarRef` so `useAutoCompact`'s exit condition triggers correctly based on available width instead of content width
+- **Proxy Takeover Toast Shows {{app}}**: Added missing `app` interpolation parameter to i18next `t()` calls for proxy takeover enabled/disabled messages
+- **Windows Protocol Handler Side Effects**: Disabled environment check and one-click install on Windows to prevent unintended protocol handler registration
+
+---
+
+## Notes & Considerations
+
+- **Common Config Snippet is back**: If you relied on this feature in v3.10.x and earlier, it works the same way again. Define shared config that should persist across all provider switches.
+- **v3.11.0 Partial Key-Field Merging users**: If you noticed missing config fields after switching providers in v3.11.0, re-import your config to restore them.
+
+---
+
+## Download & Installation
+
+Visit [Releases](https://github.com/farion1231/cc-switch/releases/latest) to download the appropriate version.
+
+### System Requirements
+
+| System  | Minimum Version                 | Architecture                        |
+| ------- | ------------------------------- | ----------------------------------- |
+| Windows | Windows 10 or later             | x64                                 |
+| macOS   | macOS 10.15 (Catalina) or later | Intel (x64) / Apple Silicon (arm64) |
+| Linux   | See table below                 | x64                                 |
+
+### Windows
+
+| File                                     | Description                                          |
+| ---------------------------------------- | ---------------------------------------------------- |
+| `CC-Switch-v3.11.1-Windows.msi`          | **Recommended** - MSI installer with auto-update     |
+| `CC-Switch-v3.11.1-Windows-Portable.zip` | Portable version, extract and run, no registry write |
+
+### macOS
+
+| File                             | Description                                                          |
+| -------------------------------- | -------------------------------------------------------------------- |
+| `CC-Switch-v3.11.1-macOS.zip`    | **Recommended** - Extract and drag to Applications, Universal Binary |
+| `CC-Switch-v3.11.1-macOS.tar.gz` | For Homebrew installation and auto-update                            |
+
+> **Note**: Since the author doesn't have an Apple Developer account, you may see an "unidentified developer" warning on first launch. Please close it, then go to "System Settings" → "Privacy & Security" → click "Open Anyway", and it will open normally afterwards.
+
+### Homebrew (macOS)
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+Update:
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| Distribution                            | Recommended Format | Installation Method                                                    |
+| --------------------------------------- | ------------------ | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`             | `sudo dpkg -i CC-Switch-*.deb` or `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`             | `sudo rpm -i CC-Switch-*.rpm` or `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`             | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage`        | Add execute permission and run directly, or use AUR                    |
+| Other distributions / Unsure            | `.AppImage`        | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/release-note-v3.11.1-ja.md

@@ -0,0 +1,122 @@
+# CC Switch v3.11.1
+
+> 部分キーフィールドマージの撤回、共通設定スニペットの復元とバグ修正
+
+**[中文版 →](release-note-v3.11.1-zh.md) | [English →](release-note-v3.11.1-en.md)**
+
+---
+
+## 概要
+
+CC Switch v3.11.1 は修正リリースです。v3.11.0 で導入された**部分キーフィールドマージ**アーキテクチャを撤回し、実績のある「**完全設定上書き + 共通設定スニペット**」メカニズムを復元しました。また、複数の UI とプラットフォーム互換性の問題を修正しています。
+
+**リリース日**: 2026-02-28
+
+**更新規模**: 8 commits | 52 files changed | +3,948 / -1,411 lines
+
+---
+
+## ハイライト
+
+- **完全設定上書き + 共通設定スニペットの復元**: 重大なデータ損失問題のため部分キーフィールドマージを撤回、完全設定スナップショット書き込みと共通設定スニペット UI を復元
+- **プロキシパネルの改善**: プロキシトグルをパネル本体に移動し、テイクオーバーオプションの発見性を向上
+- **テーマとコンパクトモードの修正**: 「システムに従う」テーマが正しく自動更新、コンパクトモードの終了が正常に動作
+- **Windows 互換性**: プロトコルハンドラーの副作用を防ぐため、環境チェックとワンクリックインストールを無効化
+
+---
+
+## 撤回
+
+### 完全設定上書き + 共通設定スニペットの復元
+
+v3.11.0 で導入された部分キーフィールドマージリファクタリングを撤回しました（revert 992dda5c）。
+
+**撤回理由**: 部分キーフィールドマージのアプローチには3つの重大な問題がありました：
+1. **切り替え時のデータ損失**: ホワイトリストにないカスタムフィールドがプロバイダー切り替え時にサイレントに破棄された
+2. **バックフィルによる永続的な剥離**: バックフィル操作がデータベースから非キーフィールドを永続的に削除し、不可逆なデータ損失を引き起こした
+3. **メンテナンス負担**: 「キーフィールド」のホワイトリストは新しい設定キーが追加されるたびに継続的なメンテナンスが必要
+
+**復元された内容**:
+- プロバイダー切り替え時の完全設定スナップショット書き込み（予測可能な完全上書き）
+- 共通設定スニペット UI およびバックエンドコマンド
+- 6つのフロントエンドファイル（コンポーネント 3つ + hooks 3つ）
+
+**移行ガイド**:
+- v3.11.0 にアップグレードしてプロバイダーのカスタムフィールドが失われた場合は、設定を再インポートするか、欠落したフィールドを手動で追加してください
+- 共通設定スニペット機能が再び利用可能です — プロバイダー切り替え時に保持すべき共有設定を定義するために使用してください
+
+---
+
+## 変更
+
+- **プロキシパネルレイアウト**: プロキシのオン/オフトグルをアコーディオンヘッダーからパネルのコンテンツエリアに移動し、アプリテイクオーバーオプションの直上に配置。プロキシを有効にした後すぐにテイクオーバー設定が見えるようになり、「プロキシだけ有効にしてテイクオーバーを設定しない」というよくある誤操作を防止
+- **OpenCode/OpenClaw の手動インポート**: 起動時の自動インポートを削除。空の状態ページに「現在の設定をインポート」ボタンを表示し、Claude/Codex/Gemini と同じ動作に統一
+
+---
+
+## 修正
+
+- **「システムに従う」テーマが自動更新されない**: Tauri のネイティブテーマ追跡（`set_window_theme(None)`）に委譲し、WebView の `prefers-color-scheme` メディアクエリが OS テーマの変更に同期するように修正
+- **コンパクトモードを終了できない**: `toolbarRef` の `flex-1` を復元し、`useAutoCompact` の終了条件がコンテンツ幅ではなく利用可能な幅に基づいて正しくトリガーされるように修正
+- **プロキシテイクオーバー Toast に {{app}} が表示される**: プロキシテイクオーバーの有効/無効メッセージの i18next `t()` 呼び出しに欠落していた `app` 補間パラメータを追加
+- **Windows プロトコルハンドラーの副作用**: 意図しないプロトコルハンドラー登録を防ぐため、Windows で環境チェックとワンクリックインストールを無効化
+
+---
+
+## 注意事項
+
+- **共通設定スニペットが復活しました**: v3.10.x 以前でこの機能を使用していた場合、同じ方法で動作します。プロバイダー切り替え時に保持すべき共有設定を定義するために使用してください。
+- **v3.11.0 部分キーフィールドマージユーザーの方へ**: v3.11.0 でプロバイダー切り替え後に設定フィールドが欠落していた場合は、設定を再インポートして復元してください。
+
+---
+
+## ダウンロードとインストール
+
+[Releases](https://github.com/farion1231/cc-switch/releases/latest) から適切なバージョンをダウンロードしてください。
+
+### システム要件
+
+| システム | 最小バージョン                   | アーキテクチャ                      |
+| -------- | -------------------------------- | ----------------------------------- |
+| Windows  | Windows 10 以降                  | x64                                 |
+| macOS    | macOS 10.15 (Catalina) 以降      | Intel (x64) / Apple Silicon (arm64) |
+| Linux    | 下表参照                         | x64                                 |
+
+### Windows
+
+| ファイル                                 | 説明                                                 |
+| ---------------------------------------- | ---------------------------------------------------- |
+| `CC-Switch-v3.11.1-Windows.msi`          | **推奨** - MSI インストーラー、自動更新対応          |
+| `CC-Switch-v3.11.1-Windows-Portable.zip` | ポータブル版、解凍して実行、レジストリ書き込みなし   |
+
+### macOS
+
+| ファイル                         | 説明                                                              |
+| -------------------------------- | ----------------------------------------------------------------- |
+| `CC-Switch-v3.11.1-macOS.zip`    | **推奨** - 解凍して Applications にドラッグ、Universal Binary     |
+| `CC-Switch-v3.11.1-macOS.tar.gz` | Homebrew インストールと自動更新用                                 |
+
+> **注意**: 作者が Apple Developer アカウントを持っていないため、初回起動時に「開発元を確認できません」という警告が表示される場合があります。一度閉じてから、「システム設定」→「プライバシーとセキュリティ」→「このまま開く」をクリックすると、その後は正常に開けます。
+
+### Homebrew (macOS)
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+更新：
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| ディストリビューション                  | 推奨形式    | インストール方法                                                       |
+| --------------------------------------- | ----------- | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`      | `sudo dpkg -i CC-Switch-*.deb` または `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`      | `sudo rpm -i CC-Switch-*.rpm` または `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`      | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage` | 実行権限を追加して直接実行、または AUR を使用                          |
+| その他のディストリビューション / 不明   | `.AppImage` | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/release-note-v3.11.1-zh.md

@@ -0,0 +1,122 @@
+# CC Switch v3.11.1
+
+> 回退部分键值合并、恢复通用配置片段与多项修复
+
+**[English →](release-note-v3.11.1-en.md) | [日本語版 →](release-note-v3.11.1-ja.md)**
+
+---
+
+## 概览
+
+CC Switch v3.11.1 是一个修复版本，回退了 v3.11.0 中引入的**部分键值合并**架构，恢复经过验证的「**全量配置覆写 + 通用配置片段**」机制，同时修复了多个 UI 和平台兼容性问题。
+
+**发布日期**：2026-02-28
+
+**更新规模**：8 commits | 52 files changed | +3,948 / -1,411 lines
+
+---
+
+## 重点内容
+
+- **恢复全量配置覆写 + 通用配置片段**：因关键数据丢失问题回退部分键值合并，恢复完整配置快照写入和通用配置片段 UI
+- **代理面板交互优化**：代理开关移入面板内部，接管选项一目了然
+- **主题与紧凑模式修复**：「跟随系统」主题现可正确自动更新，紧凑模式退出恢复正常
+- **Windows 兼容性**：禁用环境检查和一键安装，防止协议处理程序副作用
+
+---
+
+## 回退
+
+### 恢复全量配置覆写 + 通用配置片段
+
+回退了 v3.11.0 中引入的部分键值合并重构（revert 992dda5c）。
+
+**回退原因**：部分键值合并方案存在三个关键缺陷：
+1. **切换时数据丢失**：非白名单的自定义字段在供应商切换时被静默丢弃
+2. **回填永久剥离**：回填操作永久移除数据库中的非键字段，造成不可逆的数据丢失
+3. **维护成本高**：「键字段」白名单需要随新配置项不断维护，容易遗漏
+
+**恢复的内容**：
+- 供应商切换时的完整配置快照写入（可预测的全量覆写）
+- 通用配置片段 UI 及后端命令
+- 6 个前端文件（3 个组件 + 3 个 hooks）
+
+**迁移说明**：
+- 如果你在 v3.11.0 中切换供应商后丢失了自定义字段，请重新导入配置或手动补回缺失的字段
+- 通用配置片段功能已恢复——用它来定义切换供应商时需要保留的共享配置
+
+---
+
+## 变更
+
+- **代理面板交互优化**：将代理开关从折叠面板标题移入面板内部，紧邻应用接管选项。确保用户启用代理后能立即看到接管配置，避免「只开代理不接管」的常见误操作
+- **OpenCode/OpenClaw 手动导入**：移除启动时自动导入供应商配置的行为，改为在空状态页显示「导入当前配置」按钮，与 Claude/Codex/Gemini 保持一致
+
+---
+
+## 修复
+
+- **「跟随系统」主题不自动更新**：改用 Tauri 原生主题追踪（`set_window_theme(None)`），使 WebView 的 `prefers-color-scheme` 媒体查询能正确响应 OS 主题切换
+- **紧凑模式无法退出**：恢复 `toolbarRef` 上的 `flex-1` class，修复 `useAutoCompact` 的退出条件因宽度计算错误而永远不触发的问题
+- **代理接管 Toast 显示 {{app}}**：为 proxy takeover 的 i18next `t()` 调用补充缺失的 `app` 插值参数
+- **Windows 协议处理副作用**：在 Windows 上禁用环境检查和一键安装功能，防止协议处理程序注册引发的意外副作用
+
+---
+
+## 说明与注意事项
+
+- **通用配置片段已恢复**：如果你在 v3.10.x 及更早版本中使用了此功能，它的工作方式与之前完全一致。用它来定义切换供应商时需要保留的共享配置。
+- **v3.11.0 部分键值合并用户**：如果你在 v3.11.0 中切换供应商后发现配置字段丢失，请重新导入配置以恢复。
+
+---
+
+## 下载与安装
+
+访问 [Releases](https://github.com/farion1231/cc-switch/releases/latest) 下载对应版本。
+
+### 系统要求
+
+| 系统    | 最低版本                      | 架构                                |
+| ------- | ----------------------------- | ----------------------------------- |
+| Windows | Windows 10 及以上             | x64                                 |
+| macOS   | macOS 10.15 (Catalina) 及以上 | Intel (x64) / Apple Silicon (arm64) |
+| Linux   | 见下表                        | x64                                 |
+
+### Windows
+
+| 文件                                     | 说明                                |
+| ---------------------------------------- | ----------------------------------- |
+| `CC-Switch-v3.11.1-Windows.msi`          | **推荐** - MSI 安装包，支持自动更新 |
+| `CC-Switch-v3.11.1-Windows-Portable.zip` | 便携版，解压即用，不写入注册表      |
+
+### macOS
+
+| 文件                             | 说明                                                      |
+| -------------------------------- | --------------------------------------------------------- |
+| `CC-Switch-v3.11.1-macOS.zip`    | **推荐** - 解压后拖入 Applications 即可，Universal Binary |
+| `CC-Switch-v3.11.1-macOS.tar.gz` | 用于 Homebrew 安装和自动更新                              |
+
+> **注意**：由于作者没有苹果开发者账号，首次打开可能出现「未知开发者」警告，请先关闭，然后前往「系统设置」→「隐私与安全性」→ 点击「仍要打开」，之后便可以正常打开
+
+### Homebrew（macOS）
+
+```bash
+brew tap farion1231/ccswitch
+brew install --cask cc-switch
+```
+
+更新：
+
+```bash
+brew upgrade --cask cc-switch
+```
+
+### Linux
+
+| 发行版                                  | 推荐格式    | 安装方式                                                               |
+| --------------------------------------- | ----------- | ---------------------------------------------------------------------- |
+| Ubuntu / Debian / Linux Mint / Pop!\_OS | `.deb`      | `sudo dpkg -i CC-Switch-*.deb` 或 `sudo apt install ./CC-Switch-*.deb` |
+| Fedora / RHEL / CentOS / Rocky Linux    | `.rpm`      | `sudo rpm -i CC-Switch-*.rpm` 或 `sudo dnf install ./CC-Switch-*.rpm`  |
+| openSUSE                                | `.rpm`      | `sudo zypper install ./CC-Switch-*.rpm`                                |
+| Arch Linux / Manjaro                    | `.AppImage` | 添加执行权限后直接运行，或使用 AUR                                     |
+| 其他发行版 / 不确定                     | `.AppImage` | `chmod +x CC-Switch-*.AppImage && ./CC-Switch-*.AppImage`              |

docs/user-manual/README.md

@@ -99,9 +99,9 @@
 
 ## 版本信息
 
-- 文档版本：v3.10.3
-- 最后更新：2026-02-09
-- 适用于 CC Switch v3.10.0+
+- 文档版本：v3.11.1
+- 最后更新：2026-02-28
+- 适用于 CC Switch v3.11.1+
 
 ## 贡献
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-switch",
-  "version": "3.10.3",
+  "version": "3.11.1",
   "description": "All-in-One Assistant for Claude Code, Codex & Gemini CLI",
   "type": "module",
   "scripts": {
@@ -54,6 +54,7 @@
     "@lobehub/icons-static-svg": "^1.73.0",
     "@radix-ui/react-accordion": "^1.2.12",
     "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-collapsible": "^1.1.12",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
     "@radix-ui/react-label": "^2.1.7",

pnpm-lock.yaml

@@ -50,6 +50,9 @@ importers:
       '@radix-ui/react-checkbox':
         specifier: ^1.3.3
         version: 1.3.3(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
+      '@radix-ui/react-collapsible':
+        specifier: ^1.1.12
+        version: 1.1.12(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
       '@radix-ui/react-dialog':
         specifier: ^1.1.15
         version: 1.1.15(@types/react-dom@18.3.7(@types/react@18.3.23))(@types/react@18.3.23)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)

src-tauri/Cargo.lock

@@ -701,7 +701,7 @@ dependencies = [
 
 [[package]]
 name = "cc-switch"
-version = "3.10.3"
+version = "3.11.0"
 dependencies = [
  "anyhow",
  "async-stream",
@@ -714,6 +714,7 @@ dependencies = [
  "futures",
  "hyper",
  "indexmap 2.11.4",
+ "json5",
  "log",
  "objc2 0.5.2",
  "objc2-app-kit 0.2.2",
@@ -727,6 +728,7 @@ dependencies = [
  "serde_json",
  "serde_yaml",
  "serial_test",
+ "sha2",
  "tauri",
  "tauri-build",
  "tauri-plugin-deep-link",
@@ -2520,6 +2522,17 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "json5"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
+dependencies = [
+ "pest",
+ "pest_derive",
+ "serde",
+]
+
 [[package]]
 name = "jsonptr"
 version = "0.6.3"
@@ -3404,6 +3417,49 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "pest"
+version = "2.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9eb05c21a464ea704b53158d358a31e6425db2f63a1a7312268b05fe2b75f7"
+dependencies = [
+ "memchr",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68f9dbced329c441fa79d80472764b1a2c7e57123553b8519b36663a2fb234ed"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bb96d5051a78f44f43c8f712d8e810adb0ebf923fc9ed2655a7f66f63ba8ee5"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "602113b5b5e8621770cfd490cfd90b9f84ab29bd2b0e49ad83eb6d186cef2365"
+dependencies = [
+ "pest",
+ "sha2",
+]
+
 [[package]]
 name = "phf"
 version = "0.8.0"
@@ -5887,6 +5943,12 @@ version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
 [[package]]
 name = "uds_windows"
 version = "1.1.0"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cc-switch"
-version = "3.10.3"
+version = "3.11.1"
 description = "All-in-One Assistant for Claude Code, Codex & Gemini CLI"
 authors = ["Jason Young"]
 license = "MIT"
@@ -57,10 +57,12 @@ url = "2.5"
 auto-launch = "0.5"
 once_cell = "1.21.3"
 base64 = "0.22"
-rusqlite = { version = "0.31", features = ["bundled", "backup"] }
+rusqlite = { version = "0.31", features = ["bundled", "backup", "hooks"] }
 indexmap = { version = "2", features = ["serde"] }
 rust_decimal = "1.33"
 uuid = { version = "1.11", features = ["v4"] }
+sha2 = "0.10"
+json5 = "0.4"
 
 [target.'cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))'.dependencies]
 tauri-plugin-single-instance = "2"

src-tauri/src/app_config.rs

@@ -25,6 +25,7 @@ impl McpApps {
             AppType::Codex => self.codex,
             AppType::Gemini => self.gemini,
             AppType::OpenCode => self.opencode,
+            AppType::OpenClaw => false, // OpenClaw doesn't support MCP
         }
     }
 
@@ -35,6 +36,7 @@ impl McpApps {
             AppType::Codex => self.codex = enabled,
             AppType::Gemini => self.gemini = enabled,
             AppType::OpenCode => self.opencode = enabled,
+            AppType::OpenClaw => {} // OpenClaw doesn't support MCP, ignore
         }
     }
 
@@ -83,6 +85,7 @@ impl SkillApps {
             AppType::Codex => self.codex,
             AppType::Gemini => self.gemini,
             AppType::OpenCode => self.opencode,
+            AppType::OpenClaw => false, // OpenClaw doesn't support Skills
         }
     }
 
@@ -93,6 +96,7 @@ impl SkillApps {
             AppType::Codex => self.codex = enabled,
             AppType::Gemini => self.gemini = enabled,
             AppType::OpenCode => self.opencode = enabled,
+            AppType::OpenClaw => {} // OpenClaw doesn't support Skills, ignore
         }
     }
 
@@ -125,6 +129,20 @@ impl SkillApps {
         apps.set_enabled_for(app, true);
         apps
     }
+
+    /// 从来源标签列表构建启用状态
+    ///
+    /// 标签与 AppType::as_str() 一致时启用对应应用，
+    /// 其他标签（如 "agents", "cc-switch"）忽略。
+    pub fn from_labels(labels: &[String]) -> Self {
+        let mut apps = Self::default();
+        for label in labels {
+            if let Ok(app) = label.parse::<AppType>() {
+                apps.set_enabled_for(&app, true);
+            }
+        }
+        apps
+    }
 }
 
 /// 已安装的 Skill（v3.10.0+ 统一结构）
@@ -171,6 +189,8 @@ pub struct UnmanagedSkill {
     pub description: Option<String>,
     /// 在哪些应用目录中发现（如 ["claude", "codex"]）
     pub found_in: Vec<String>,
+    /// 发现路径（首个匹配的完整路径）
+    pub path: String,
 }
 
 /// MCP 服务器定义（v3.7.0 统一结构）
@@ -222,6 +242,9 @@ pub struct McpRoot {
     /// OpenCode MCP 配置（v4.0.0+，实际使用 opencode.json）
     #[serde(default, skip_serializing_if = "McpConfig::is_empty")]
     pub opencode: McpConfig,
+    /// OpenClaw MCP 配置（v4.1.0+，实际使用 openclaw.json）
+    #[serde(default, skip_serializing_if = "McpConfig::is_empty")]
+    pub openclaw: McpConfig,
 }
 
 impl Default for McpRoot {
@@ -234,6 +257,7 @@ impl Default for McpRoot {
             codex: McpConfig::default(),
             gemini: McpConfig::default(),
             opencode: McpConfig::default(),
+            openclaw: McpConfig::default(),
         }
     }
 }
@@ -256,6 +280,8 @@ pub struct PromptRoot {
     pub gemini: PromptConfig,
     #[serde(default)]
     pub opencode: PromptConfig,
+    #[serde(default)]
+    pub openclaw: PromptConfig,
 }
 
 use crate::config::{copy_file, get_app_config_dir, get_app_config_path, write_json_file};
@@ -271,6 +297,7 @@ pub enum AppType {
     Codex,
     Gemini,
     OpenCode,
+    OpenClaw,
 }
 
 impl AppType {
@@ -280,15 +307,16 @@ impl AppType {
             AppType::Codex => "codex",
             AppType::Gemini => "gemini",
             AppType::OpenCode => "opencode",
+            AppType::OpenClaw => "openclaw",
         }
     }
 
     /// Check if this app uses additive mode
     ///
     /// - Switch mode (false): Only the current provider is written to live config (Claude, Codex, Gemini)
-    /// - Additive mode (true): All providers are written to live config (OpenCode)
+    /// - Additive mode (true): All providers are written to live config (OpenCode, OpenClaw)
     pub fn is_additive_mode(&self) -> bool {
-        matches!(self, AppType::OpenCode)
+        matches!(self, AppType::OpenCode | AppType::OpenClaw)
     }
 
     /// Return an iterator over all app types
@@ -298,6 +326,7 @@ impl AppType {
             AppType::Codex,
             AppType::Gemini,
             AppType::OpenCode,
+            AppType::OpenClaw,
         ]
         .into_iter()
     }
@@ -313,10 +342,11 @@ impl FromStr for AppType {
             "codex" => Ok(AppType::Codex),
             "gemini" => Ok(AppType::Gemini),
             "opencode" => Ok(AppType::OpenCode),
+            "openclaw" => Ok(AppType::OpenClaw),
             other => Err(AppError::localized(
                 "unsupported_app",
-                format!("不支持的应用标识: '{other}'。可选值: claude, codex, gemini, opencode。"),
-                format!("Unsupported app id: '{other}'. Allowed: claude, codex, gemini, opencode."),
+                format!("不支持的应用标识: '{other}'。可选值: claude, codex, gemini, opencode, openclaw。"),
+                format!("Unsupported app id: '{other}'. Allowed: claude, codex, gemini, opencode, openclaw."),
             )),
         }
     }
@@ -336,6 +366,9 @@ pub struct CommonConfigSnippets {
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub opencode: Option<String>,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub openclaw: Option<String>,
 }
 
 impl CommonConfigSnippets {
@@ -346,6 +379,7 @@ impl CommonConfigSnippets {
             AppType::Codex => self.codex.as_ref(),
             AppType::Gemini => self.gemini.as_ref(),
             AppType::OpenCode => self.opencode.as_ref(),
+            AppType::OpenClaw => self.openclaw.as_ref(),
         }
     }
 
@@ -356,6 +390,7 @@ impl CommonConfigSnippets {
             AppType::Codex => self.codex = snippet,
             AppType::Gemini => self.gemini = snippet,
             AppType::OpenCode => self.opencode = snippet,
+            AppType::OpenClaw => self.openclaw = snippet,
         }
     }
 }
@@ -396,6 +431,7 @@ impl Default for MultiAppConfig {
         apps.insert("codex".to_string(), ProviderManager::default());
         apps.insert("gemini".to_string(), ProviderManager::default());
         apps.insert("opencode".to_string(), ProviderManager::default());
+        apps.insert("openclaw".to_string(), ProviderManager::default());
 
         Self {
             version: 2,
@@ -555,6 +591,7 @@ impl MultiAppConfig {
             AppType::Codex => &self.mcp.codex,
             AppType::Gemini => &self.mcp.gemini,
             AppType::OpenCode => &self.mcp.opencode,
+            AppType::OpenClaw => &self.mcp.openclaw,
         }
     }
 
@@ -565,6 +602,7 @@ impl MultiAppConfig {
             AppType::Codex => &mut self.mcp.codex,
             AppType::Gemini => &mut self.mcp.gemini,
             AppType::OpenCode => &mut self.mcp.opencode,
+            AppType::OpenClaw => &mut self.mcp.openclaw,
         }
     }
 
@@ -579,6 +617,7 @@ impl MultiAppConfig {
         Self::auto_import_prompt_if_exists(&mut config, AppType::Codex)?;
         Self::auto_import_prompt_if_exists(&mut config, AppType::Gemini)?;
         Self::auto_import_prompt_if_exists(&mut config, AppType::OpenCode)?;
+        Self::auto_import_prompt_if_exists(&mut config, AppType::OpenClaw)?;
 
         Ok(config)
     }
@@ -599,6 +638,7 @@ impl MultiAppConfig {
             || !self.prompts.codex.prompts.is_empty()
             || !self.prompts.gemini.prompts.is_empty()
             || !self.prompts.opencode.prompts.is_empty()
+            || !self.prompts.openclaw.prompts.is_empty()
         {
             return Ok(false);
         }
@@ -611,6 +651,7 @@ impl MultiAppConfig {
             AppType::Codex,
             AppType::Gemini,
             AppType::OpenCode,
+            AppType::OpenClaw,
         ] {
             // 复用已有的单应用导入逻辑
             if Self::auto_import_prompt_if_exists(self, app)? {
@@ -681,6 +722,7 @@ impl MultiAppConfig {
             AppType::Codex => &mut config.prompts.codex.prompts,
             AppType::Gemini => &mut config.prompts.gemini.prompts,
             AppType::OpenCode => &mut config.prompts.opencode.prompts,
+            AppType::OpenClaw => &mut config.prompts.openclaw.prompts,
         };
 
         prompts.insert(id, prompt);
@@ -709,12 +751,18 @@ impl MultiAppConfig {
         let mut conflicts = Vec::new();
 
         // 收集所有应用的 MCP
-        for app in [AppType::Claude, AppType::Codex, AppType::Gemini] {
+        for app in [
+            AppType::Claude,
+            AppType::Codex,
+            AppType::Gemini,
+            AppType::OpenCode,
+        ] {
             let old_servers = match app {
                 AppType::Claude => &self.mcp.claude.servers,
                 AppType::Codex => &self.mcp.codex.servers,
                 AppType::Gemini => &self.mcp.gemini.servers,
                 AppType::OpenCode => &self.mcp.opencode.servers,
+                AppType::OpenClaw => continue, // OpenClaw MCP is still in development, skip
             };
 
             for (id, entry) in old_servers {

src-tauri/src/commands/config.rs

@@ -59,6 +59,15 @@ pub async fn get_config_status(app: String) -> Result<ConfigStatus, String> {
 
             Ok(ConfigStatus { exists, path })
         }
+        AppType::OpenClaw => {
+            let config_path = crate::openclaw_config::get_openclaw_config_path();
+            let exists = config_path.exists();
+            let path = crate::openclaw_config::get_openclaw_dir()
+                .to_string_lossy()
+                .to_string();
+
+            Ok(ConfigStatus { exists, path })
+        }
     }
 }
 
@@ -74,6 +83,7 @@ pub async fn get_config_dir(app: String) -> Result<String, String> {
         AppType::Codex => codex_config::get_codex_config_dir(),
         AppType::Gemini => crate::gemini_config::get_gemini_dir(),
         AppType::OpenCode => crate::opencode_config::get_opencode_dir(),
+        AppType::OpenClaw => crate::openclaw_config::get_openclaw_dir(),
     };
 
     Ok(dir.to_string_lossy().to_string())
@@ -86,6 +96,7 @@ pub async fn open_config_folder(handle: AppHandle, app: String) -> Result<bool,
         AppType::Codex => codex_config::get_codex_config_dir(),
         AppType::Gemini => crate::gemini_config::get_gemini_dir(),
         AppType::OpenCode => crate::opencode_config::get_opencode_dir(),
+        AppType::OpenClaw => crate::openclaw_config::get_openclaw_dir(),
     };
 
     if !config_dir.exists() {
@@ -204,7 +215,7 @@ pub async fn set_common_config_snippet(
 ) -> Result<(), String> {
     if !snippet.trim().is_empty() {
         match app_type.as_str() {
-            "claude" | "gemini" | "omo" => {
+            "claude" | "gemini" | "omo" | "omo-slim" => {
                 serde_json::from_str::<serde_json::Value>(&snippet)
                     .map_err(invalid_json_format_error)?;
             }
@@ -227,12 +238,28 @@ pub async fn set_common_config_snippet(
     if app_type == "omo"
         && state
             .db
-            .get_current_omo_provider("opencode")
+            .get_current_omo_provider("opencode", "omo")
             .map_err(|e| e.to_string())?
             .is_some()
     {
-        crate::services::OmoService::write_config_to_file(state.inner())
-            .map_err(|e| e.to_string())?;
+        crate::services::OmoService::write_config_to_file(
+            state.inner(),
+            &crate::services::omo::STANDARD,
+        )
+        .map_err(|e| e.to_string())?;
+    }
+    if app_type == "omo-slim"
+        && state
+            .db
+            .get_current_omo_provider("opencode", "omo-slim")
+            .map_err(|e| e.to_string())?
+            .is_some()
+    {
+        crate::services::OmoService::write_config_to_file(
+            state.inner(),
+            &crate::services::omo::SLIM,
+        )
+        .map_err(|e| e.to_string())?;
     }
     Ok(())
 }

src-tauri/src/commands/import_export.rs

@@ -5,10 +5,17 @@ use std::path::PathBuf;
 use tauri::State;
 use tauri_plugin_dialog::DialogExt;
 
+use crate::commands::sync_support::{
+    post_sync_warning_from_result, run_post_import_sync, success_payload_with_warning,
+};
+use crate::database::backup::BackupEntry;
+use crate::database::Database;
 use crate::error::AppError;
 use crate::services::provider::ProviderService;
 use crate::store::AppState;
 
+// ─── File import/export ──────────────────────────────────────
+
 /// 导出数据库为 SQL 备份
 #[tauri::command]
 pub async fn export_config_to_file(
@@ -37,27 +44,15 @@ pub async fn import_config_from_file(
     state: State<'_, AppState>,
 ) -> Result<Value, String> {
     let db = state.db.clone();
-    let db_for_state = db.clone();
+    let db_for_sync = db.clone();
     tauri::async_runtime::spawn_blocking(move || {
         let path_buf = PathBuf::from(&filePath);
         let backup_id = db.import_sql(&path_buf)?;
-
-        // 导入后同步当前供应商到各自的 live 配置
-        let app_state = AppState::new(db_for_state);
-        if let Err(err) = ProviderService::sync_current_to_live(&app_state) {
-            log::warn!("导入后同步 live 配置失败: {err}");
+        let warning = post_sync_warning_from_result(Ok(run_post_import_sync(db_for_sync)));
+        if let Some(msg) = warning.as_ref() {
+            log::warn!("[Import] post-import sync warning: {msg}");
         }
-
-        // 重新加载设置到内存缓存，确保导入的设置生效
-        if let Err(err) = crate::settings::reload_settings() {
-            log::warn!("导入后重载设置失败: {err}");
-        }
-
-        Ok::<_, AppError>(json!({
-            "success": true,
-            "message": "SQL imported successfully",
-            "backupId": backup_id
-        }))
+        Ok::<_, AppError>(success_payload_with_warning(backup_id, warning))
     })
     .await
     .map_err(|e| format!("导入配置失败: {e}"))?
@@ -80,6 +75,8 @@ pub async fn sync_current_providers_live(state: State<'_, AppState>) -> Result<V
     .map_err(|e: AppError| e.to_string())
 }
 
+// ─── File dialogs ────────────────────────────────────────────
+
 /// 保存文件对话框
 #[tauri::command]
 pub async fn save_file_dialog<R: tauri::Runtime>(
@@ -123,3 +120,57 @@ pub async fn open_zip_file_dialog<R: tauri::Runtime>(
 
     Ok(result.map(|p| p.to_string()))
 }
+
+// ─── Database backup management ─────────────────────────────
+
+/// Manually create a database backup
+#[tauri::command]
+pub async fn create_db_backup(state: State<'_, AppState>) -> Result<String, String> {
+    let db = state.db.clone();
+    tauri::async_runtime::spawn_blocking(move || match db.backup_database_file()? {
+        Some(path) => Ok(path
+            .file_name()
+            .map(|f| f.to_string_lossy().into_owned())
+            .unwrap_or_default()),
+        None => Err(AppError::Config(
+            "Database file not found, backup skipped".to_string(),
+        )),
+    })
+    .await
+    .map_err(|e| format!("Backup failed: {e}"))?
+    .map_err(|e: AppError| e.to_string())
+}
+
+/// List all database backup files
+#[tauri::command]
+pub fn list_db_backups() -> Result<Vec<BackupEntry>, String> {
+    Database::list_backups().map_err(|e| e.to_string())
+}
+
+/// Restore database from a backup file
+#[tauri::command]
+pub async fn restore_db_backup(
+    state: State<'_, AppState>,
+    filename: String,
+) -> Result<String, String> {
+    let db = state.db.clone();
+    tauri::async_runtime::spawn_blocking(move || db.restore_from_backup(&filename))
+        .await
+        .map_err(|e| format!("Restore failed: {e}"))?
+        .map_err(|e: AppError| e.to_string())
+}
+
+/// Rename a database backup file
+#[tauri::command]
+pub fn rename_db_backup(
+    #[allow(non_snake_case)] oldFilename: String,
+    #[allow(non_snake_case)] newName: String,
+) -> Result<String, String> {
+    Database::rename_backup(&oldFilename, &newName).map_err(|e| e.to_string())
+}
+
+/// Delete a database backup file
+#[tauri::command]
+pub fn delete_db_backup(filename: String) -> Result<(), String> {
+    Database::delete_backup(&filename).map_err(|e| e.to_string())
+}

src-tauri/src/commands/misc.rs

@@ -5,6 +5,7 @@ use crate::init_status::{InitErrorPayload, SkillsMigrationPayload};
 use crate::services::ProviderService;
 use once_cell::sync::Lazy;
 use regex::Regex;
+use std::collections::HashMap;
 use std::path::Path;
 use std::str::FromStr;
 use tauri::AppHandle;
@@ -85,50 +86,135 @@ pub struct ToolVersion {
     version: Option<String>,
     latest_version: Option<String>, // 新增字段：最新版本
     error: Option<String>,
+    /// 工具运行环境: "windows", "wsl", "macos", "linux", "unknown"
+    env_type: String,
+    /// 当 env_type 为 "wsl" 时，返回该工具绑定的 WSL distro（用于按 distro 探测 shells）
+    wsl_distro: Option<String>,
+}
+
+const VALID_TOOLS: [&str; 4] = ["claude", "codex", "gemini", "opencode"];
+
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WslShellPreferenceInput {
+    #[serde(default)]
+    pub wsl_shell: Option<String>,
+    #[serde(default)]
+    pub wsl_shell_flag: Option<String>,
+}
+
+// Keep platform-specific env detection in one place to avoid repeating cfg blocks.
+#[cfg(target_os = "windows")]
+fn tool_env_type_and_wsl_distro(tool: &str) -> (String, Option<String>) {
+    if let Some(distro) = wsl_distro_for_tool(tool) {
+        ("wsl".to_string(), Some(distro))
+    } else {
+        ("windows".to_string(), None)
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn tool_env_type_and_wsl_distro(_tool: &str) -> (String, Option<String>) {
+    ("macos".to_string(), None)
+}
+
+#[cfg(target_os = "linux")]
+fn tool_env_type_and_wsl_distro(_tool: &str) -> (String, Option<String>) {
+    ("linux".to_string(), None)
+}
+
+#[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
+fn tool_env_type_and_wsl_distro(_tool: &str) -> (String, Option<String>) {
+    ("unknown".to_string(), None)
 }
 
 #[tauri::command]
-pub async fn get_tool_versions() -> Result<Vec<ToolVersion>, String> {
-    let tools = vec!["claude", "codex", "gemini", "opencode"];
-    let mut results = Vec::new();
+pub async fn get_tool_versions(
+    tools: Option<Vec<String>>,
+    wsl_shell_by_tool: Option<HashMap<String, WslShellPreferenceInput>>,
+) -> Result<Vec<ToolVersion>, String> {
+    // Windows: completely disable tool version detection to prevent
+    // accidentally launching apps (e.g. Claude Code) via protocol handlers.
+    #[cfg(target_os = "windows")]
+    {
+        let _ = (tools, wsl_shell_by_tool);
+        return Ok(Vec::new());
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let requested: Vec<&str> = if let Some(tools) = tools.as_ref() {
+            let set: std::collections::HashSet<&str> = tools.iter().map(|s| s.as_str()).collect();
+            VALID_TOOLS
+                .iter()
+                .copied()
+                .filter(|t| set.contains(t))
+                .collect()
+        } else {
+            VALID_TOOLS.to_vec()
+        };
+        let mut results = Vec::new();
+
+        for tool in requested {
+            let pref = wsl_shell_by_tool.as_ref().and_then(|m| m.get(tool));
+            let tool_wsl_shell = pref.and_then(|p| p.wsl_shell.as_deref());
+            let tool_wsl_shell_flag = pref.and_then(|p| p.wsl_shell_flag.as_deref());
+
+            results.push(
+                get_single_tool_version_impl(tool, tool_wsl_shell, tool_wsl_shell_flag).await,
+            );
+        }
+
+        Ok(results)
+    }
+}
+
+/// 获取单个工具的版本信息（内部实现）
+async fn get_single_tool_version_impl(
+    tool: &str,
+    wsl_shell: Option<&str>,
+    wsl_shell_flag: Option<&str>,
+) -> ToolVersion {
+    debug_assert!(
+        VALID_TOOLS.contains(&tool),
+        "unexpected tool name in get_single_tool_version_impl: {tool}"
+    );
+
+    // 判断该工具的运行环境 & WSL distro（如有）
+    let (env_type, wsl_distro) = tool_env_type_and_wsl_distro(tool);
 
     // 使用全局 HTTP 客户端（已包含代理配置）
     let client = crate::proxy::http_client::get();
 
-    for tool in tools {
-        // 1. 获取本地版本 - 先尝试直接执行，失败则扫描常见路径
-        let (local_version, local_error) = if let Some(distro) = wsl_distro_for_tool(tool) {
-            try_get_version_wsl(tool, &distro)
+    // 1. 获取本地版本
+    let (local_version, local_error) = if let Some(distro) = wsl_distro.as_deref() {
+        try_get_version_wsl(tool, distro, wsl_shell, wsl_shell_flag)
+    } else {
+        let direct_result = try_get_version(tool);
+        if direct_result.0.is_some() {
+            direct_result
         } else {
-            // 先尝试直接执行
-            let direct_result = try_get_version(tool);
+            scan_cli_version(tool)
+        }
+    };
 
-            if direct_result.0.is_some() {
-                direct_result
-            } else {
-                // 扫描常见的 npm 全局安装路径
-                scan_cli_version(tool)
-            }
-        };
+    // 2. 获取远程最新版本
+    let latest_version = match tool {
+        "claude" => fetch_npm_latest_version(&client, "@anthropic-ai/claude-code").await,
+        "codex" => fetch_npm_latest_version(&client, "@openai/codex").await,
+        "gemini" => fetch_npm_latest_version(&client, "@google/gemini-cli").await,
+        "opencode" => fetch_github_latest_version(&client, "anomalyco/opencode").await,
+        _ => None,
+    };
 
-        // 2. 获取远程最新版本
-        let latest_version = match tool {
-            "claude" => fetch_npm_latest_version(&client, "@anthropic-ai/claude-code").await,
-            "codex" => fetch_npm_latest_version(&client, "@openai/codex").await,
-            "gemini" => fetch_npm_latest_version(&client, "@google/gemini-cli").await,
-            "opencode" => fetch_github_latest_version(&client, "anomalyco/opencode").await,
-            _ => None,
-        };
-
-        results.push(ToolVersion {
-            name: tool.to_string(),
-            version: local_version,
-            latest_version,
-            error: local_error,
-        });
+    ToolVersion {
+        name: tool.to_string(),
+        version: local_version,
+        latest_version,
+        error: local_error,
+        env_type,
+        wsl_distro,
     }
-
-    Ok(results)
 }
 
 /// Helper function to fetch latest version from npm registry
@@ -242,8 +328,38 @@ fn is_valid_wsl_distro_name(name: &str) -> bool {
             .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.')
 }
 
+/// Validate that the given shell name is one of the allowed shells.
 #[cfg(target_os = "windows")]
-fn try_get_version_wsl(tool: &str, distro: &str) -> (Option<String>, Option<String>) {
+fn is_valid_shell(shell: &str) -> bool {
+    matches!(
+        shell.rsplit('/').next().unwrap_or(shell),
+        "sh" | "bash" | "zsh" | "fish" | "dash"
+    )
+}
+
+/// Validate that the given shell flag is one of the allowed flags.
+#[cfg(target_os = "windows")]
+fn is_valid_shell_flag(flag: &str) -> bool {
+    matches!(flag, "-c" | "-lc" | "-lic")
+}
+
+/// Return the default invocation flag for the given shell.
+#[cfg(target_os = "windows")]
+fn default_flag_for_shell(shell: &str) -> &'static str {
+    match shell.rsplit('/').next().unwrap_or(shell) {
+        "dash" | "sh" => "-c",
+        "fish" => "-lc",
+        _ => "-lic",
+    }
+}
+
+#[cfg(target_os = "windows")]
+fn try_get_version_wsl(
+    tool: &str,
+    distro: &str,
+    force_shell: Option<&str>,
+    force_shell_flag: Option<&str>,
+) -> (Option<String>, Option<String>) {
     use std::process::Command;
 
     // 防御性断言：tool 只能是预定义的值
@@ -257,15 +373,47 @@ fn try_get_version_wsl(tool: &str, distro: &str) -> (Option<String>, Option<Stri
         return (None, Some(format!("[WSL:{distro}] invalid distro name")));
     }
 
+    // 构建 Shell 脚本检测逻辑
+    let (shell, flag, cmd) = if let Some(shell) = force_shell {
+        // Defensive validation: never allow an arbitrary executable name here.
+        if !is_valid_shell(shell) {
+            return (None, Some(format!("[WSL:{distro}] invalid shell: {shell}")));
+        }
+        let shell = shell.rsplit('/').next().unwrap_or(shell);
+        let flag = if let Some(flag) = force_shell_flag {
+            if !is_valid_shell_flag(flag) {
+                return (
+                    None,
+                    Some(format!("[WSL:{distro}] invalid shell flag: {flag}")),
+                );
+            }
+            flag
+        } else {
+            default_flag_for_shell(shell)
+        };
+
+        (shell.to_string(), flag, format!("{tool} --version"))
+    } else {
+        let cmd = if let Some(flag) = force_shell_flag {
+            if !is_valid_shell_flag(flag) {
+                return (
+                    None,
+                    Some(format!("[WSL:{distro}] invalid shell flag: {flag}")),
+                );
+            }
+            format!("\"${{SHELL:-sh}}\" {flag} '{tool} --version'")
+        } else {
+            // 兜底：自动尝试 -lic, -lc, -c
+            format!(
+                "\"${{SHELL:-sh}}\" -lic '{tool} --version' 2>/dev/null || \"${{SHELL:-sh}}\" -lc '{tool} --version' 2>/dev/null || \"${{SHELL:-sh}}\" -c '{tool} --version'"
+            )
+        };
+
+        ("sh".to_string(), "-c", cmd)
+    };
+
     let output = Command::new("wsl.exe")
-        .args([
-            "-d",
-            distro,
-            "--",
-            "sh",
-            "-lc",
-            &format!("{tool} --version"),
-        ])
+        .args(["-d", distro, "--", &shell, flag, &cmd])
         .creation_flags(CREATE_NO_WINDOW)
         .output();
 
@@ -306,13 +454,91 @@ fn try_get_version_wsl(tool: &str, distro: &str) -> (Option<String>, Option<Stri
 /// 注意：此函数实际上不会被调用，因为 `wsl_distro_from_path` 在非 Windows 平台总是返回 None。
 /// 保留此函数是为了保持 API 一致性，防止未来重构时遗漏。
 #[cfg(not(target_os = "windows"))]
-fn try_get_version_wsl(_tool: &str, _distro: &str) -> (Option<String>, Option<String>) {
+fn try_get_version_wsl(
+    _tool: &str,
+    _distro: &str,
+    _force_shell: Option<&str>,
+    _force_shell_flag: Option<&str>,
+) -> (Option<String>, Option<String>) {
     (
         None,
         Some("WSL check not supported on this platform".to_string()),
     )
 }
 
+fn push_unique_path(paths: &mut Vec<std::path::PathBuf>, path: std::path::PathBuf) {
+    if path.as_os_str().is_empty() {
+        return;
+    }
+
+    if !paths.iter().any(|existing| existing == &path) {
+        paths.push(path);
+    }
+}
+
+fn push_env_single_dir(paths: &mut Vec<std::path::PathBuf>, value: Option<std::ffi::OsString>) {
+    if let Some(raw) = value {
+        push_unique_path(paths, std::path::PathBuf::from(raw));
+    }
+}
+
+fn extend_from_path_list(
+    paths: &mut Vec<std::path::PathBuf>,
+    value: Option<std::ffi::OsString>,
+    suffix: Option<&str>,
+) {
+    if let Some(raw) = value {
+        for p in std::env::split_paths(&raw) {
+            let dir = match suffix {
+                Some(s) => p.join(s),
+                None => p,
+            };
+            push_unique_path(paths, dir);
+        }
+    }
+}
+
+/// OpenCode install.sh 路径优先级（见 https://github.com/anomalyco/opencode README）:
+///   $OPENCODE_INSTALL_DIR > $XDG_BIN_DIR > $HOME/bin > $HOME/.opencode/bin
+/// 额外扫描 Go 安装路径（~/go/bin、$GOPATH/*/bin）。
+fn opencode_extra_search_paths(
+    home: &Path,
+    opencode_install_dir: Option<std::ffi::OsString>,
+    xdg_bin_dir: Option<std::ffi::OsString>,
+    gopath: Option<std::ffi::OsString>,
+) -> Vec<std::path::PathBuf> {
+    let mut paths = Vec::new();
+
+    push_env_single_dir(&mut paths, opencode_install_dir);
+    push_env_single_dir(&mut paths, xdg_bin_dir);
+
+    if !home.as_os_str().is_empty() {
+        push_unique_path(&mut paths, home.join("bin"));
+        push_unique_path(&mut paths, home.join(".opencode").join("bin"));
+        push_unique_path(&mut paths, home.join("go").join("bin"));
+    }
+
+    extend_from_path_list(&mut paths, gopath, Some("bin"));
+
+    paths
+}
+
+fn tool_executable_candidates(tool: &str, dir: &Path) -> Vec<std::path::PathBuf> {
+    #[cfg(target_os = "windows")]
+    {
+        vec![
+            dir.join(format!("{tool}.cmd")),
+            dir.join(format!("{tool}.exe")),
+            dir.join(tool),
+        ]
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        vec![dir.join(tool)]
+    }
+}
+
 /// 扫描常见路径查找 CLI
 fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
     use std::process::Command;
@@ -320,88 +546,99 @@ fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
     let home = dirs::home_dir().unwrap_or_default();
 
     // 常见的安装路径（原生安装优先）
-    let mut search_paths: Vec<std::path::PathBuf> = vec![
-        home.join(".local/bin"), // Native install (official recommended)
-        home.join(".npm-global/bin"),
-        home.join("n/bin"),      // n version manager
-        home.join(".volta/bin"), // Volta package manager
-    ];
+    let mut search_paths: Vec<std::path::PathBuf> = Vec::new();
+    if !home.as_os_str().is_empty() {
+        push_unique_path(&mut search_paths, home.join(".local/bin"));
+        push_unique_path(&mut search_paths, home.join(".npm-global/bin"));
+        push_unique_path(&mut search_paths, home.join("n/bin"));
+        push_unique_path(&mut search_paths, home.join(".volta/bin"));
+    }
 
     #[cfg(target_os = "macos")]
     {
-        search_paths.push(std::path::PathBuf::from("/opt/homebrew/bin"));
-        search_paths.push(std::path::PathBuf::from("/usr/local/bin"));
+        push_unique_path(
+            &mut search_paths,
+            std::path::PathBuf::from("/opt/homebrew/bin"),
+        );
+        push_unique_path(
+            &mut search_paths,
+            std::path::PathBuf::from("/usr/local/bin"),
+        );
     }
 
     #[cfg(target_os = "linux")]
     {
-        search_paths.push(std::path::PathBuf::from("/usr/local/bin"));
-        search_paths.push(std::path::PathBuf::from("/usr/bin"));
+        push_unique_path(
+            &mut search_paths,
+            std::path::PathBuf::from("/usr/local/bin"),
+        );
+        push_unique_path(&mut search_paths, std::path::PathBuf::from("/usr/bin"));
     }
 
     #[cfg(target_os = "windows")]
     {
         if let Some(appdata) = dirs::data_dir() {
-            search_paths.push(appdata.join("npm"));
+            push_unique_path(&mut search_paths, appdata.join("npm"));
         }
-        search_paths.push(std::path::PathBuf::from("C:\\Program Files\\nodejs"));
+        push_unique_path(
+            &mut search_paths,
+            std::path::PathBuf::from("C:\\Program Files\\nodejs"),
+        );
     }
 
-    // 添加 fnm 路径支持
     let fnm_base = home.join(".local/state/fnm_multishells");
     if fnm_base.exists() {
         if let Ok(entries) = std::fs::read_dir(&fnm_base) {
             for entry in entries.flatten() {
                 let bin_path = entry.path().join("bin");
                 if bin_path.exists() {
-                    search_paths.push(bin_path);
+                    push_unique_path(&mut search_paths, bin_path);
                 }
             }
         }
     }
 
-    // 扫描 nvm 目录下的所有 node 版本
     let nvm_base = home.join(".nvm/versions/node");
     if nvm_base.exists() {
         if let Ok(entries) = std::fs::read_dir(&nvm_base) {
             for entry in entries.flatten() {
                 let bin_path = entry.path().join("bin");
                 if bin_path.exists() {
-                    search_paths.push(bin_path);
+                    push_unique_path(&mut search_paths, bin_path);
                 }
             }
         }
     }
 
-    // 添加 Go 路径支持 (opencode 使用 go install 安装)
     if tool == "opencode" {
-        search_paths.push(home.join("go/bin")); // go install 默认路径
-        if let Ok(gopath) = std::env::var("GOPATH") {
-            search_paths.push(std::path::PathBuf::from(gopath).join("bin"));
+        let extra_paths = opencode_extra_search_paths(
+            &home,
+            std::env::var_os("OPENCODE_INSTALL_DIR"),
+            std::env::var_os("XDG_BIN_DIR"),
+            std::env::var_os("GOPATH"),
+        );
+
+        for path in extra_paths {
+            push_unique_path(&mut search_paths, path);
         }
     }
 
-    // 在每个路径中查找工具
+    let current_path = std::env::var("PATH").unwrap_or_default();
+
     for path in &search_paths {
-        let tool_path = if cfg!(target_os = "windows") {
-            path.join(format!("{tool}.cmd"))
-        } else {
-            path.join(tool)
-        };
+        #[cfg(target_os = "windows")]
+        let new_path = format!("{};{}", path.display(), current_path);
 
-        if tool_path.exists() {
-            // 构建 PATH 环境变量，确保 node 可被找到
-            let current_path = std::env::var("PATH").unwrap_or_default();
+        #[cfg(not(target_os = "windows"))]
+        let new_path = format!("{}:{}", path.display(), current_path);
 
-            #[cfg(target_os = "windows")]
-            let new_path = format!("{};{}", path.display(), current_path);
-
-            #[cfg(not(target_os = "windows"))]
-            let new_path = format!("{}:{}", path.display(), current_path);
+        for tool_path in tool_executable_candidates(tool, path) {
+            if !tool_path.exists() {
+                continue;
+            }
 
             #[cfg(target_os = "windows")]
             let output = {
-                // 使用 cmd /C 包装执行，确保子进程也在隐藏的控制台中运行
                 Command::new("cmd")
                     .args(["/C", &format!("\"{}\" --version", tool_path.display())])
                     .env("PATH", &new_path)
@@ -433,6 +670,7 @@ fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
     (None, Some("not installed or not executable".to_string()))
 }
 
+#[cfg(target_os = "windows")]
 fn wsl_distro_for_tool(tool: &str) -> Option<String> {
     let override_dir = match tool {
         "claude" => crate::settings::get_claude_override_dir(),
@@ -470,12 +708,6 @@ fn wsl_distro_from_path(path: &Path) -> Option<String> {
     }
 }
 
-/// 非 Windows 平台不支持 WSL 路径解析
-#[cfg(not(target_os = "windows"))]
-fn wsl_distro_from_path(_path: &Path) -> Option<String> {
-    None
-}
-
 /// 打开指定提供商的终端
 ///
 /// 根据提供商配置的环境变量启动一个带有该提供商特定设置的终端
@@ -971,3 +1203,124 @@ pub async fn set_window_theme(window: tauri::Window, theme: String) -> Result<()
 
     window.set_theme(tauri_theme).map_err(|e| e.to_string())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_extract_version() {
+        assert_eq!(extract_version("claude 1.0.20"), "1.0.20");
+        assert_eq!(extract_version("v2.3.4-beta.1"), "2.3.4-beta.1");
+        assert_eq!(extract_version("no version here"), "no version here");
+    }
+
+    #[cfg(target_os = "windows")]
+    mod wsl_helpers {
+        use super::super::*;
+
+        #[test]
+        fn test_is_valid_shell() {
+            assert!(is_valid_shell("bash"));
+            assert!(is_valid_shell("zsh"));
+            assert!(is_valid_shell("sh"));
+            assert!(is_valid_shell("fish"));
+            assert!(is_valid_shell("dash"));
+            assert!(is_valid_shell("/usr/bin/bash"));
+            assert!(is_valid_shell("/bin/zsh"));
+            assert!(!is_valid_shell("powershell"));
+            assert!(!is_valid_shell("cmd"));
+            assert!(!is_valid_shell(""));
+        }
+
+        #[test]
+        fn test_is_valid_shell_flag() {
+            assert!(is_valid_shell_flag("-c"));
+            assert!(is_valid_shell_flag("-lc"));
+            assert!(is_valid_shell_flag("-lic"));
+            assert!(!is_valid_shell_flag("-x"));
+            assert!(!is_valid_shell_flag(""));
+            assert!(!is_valid_shell_flag("--login"));
+        }
+
+        #[test]
+        fn test_default_flag_for_shell() {
+            assert_eq!(default_flag_for_shell("sh"), "-c");
+            assert_eq!(default_flag_for_shell("dash"), "-c");
+            assert_eq!(default_flag_for_shell("/bin/dash"), "-c");
+            assert_eq!(default_flag_for_shell("fish"), "-lc");
+            assert_eq!(default_flag_for_shell("bash"), "-lic");
+            assert_eq!(default_flag_for_shell("zsh"), "-lic");
+            assert_eq!(default_flag_for_shell("/usr/bin/zsh"), "-lic");
+        }
+
+        #[test]
+        fn test_is_valid_wsl_distro_name() {
+            assert!(is_valid_wsl_distro_name("Ubuntu"));
+            assert!(is_valid_wsl_distro_name("Ubuntu-22.04"));
+            assert!(is_valid_wsl_distro_name("my_distro"));
+            assert!(!is_valid_wsl_distro_name(""));
+            assert!(!is_valid_wsl_distro_name("distro with spaces"));
+            assert!(!is_valid_wsl_distro_name(&"a".repeat(65)));
+        }
+    }
+
+    #[test]
+    fn opencode_extra_search_paths_includes_install_and_fallback_dirs() {
+        let home = PathBuf::from("/home/tester");
+        let install_dir = Some(std::ffi::OsString::from("/custom/opencode/bin"));
+        let xdg_bin_dir = Some(std::ffi::OsString::from("/xdg/bin"));
+        let gopath =
+            std::env::join_paths([PathBuf::from("/go/path1"), PathBuf::from("/go/path2")]).ok();
+
+        let paths = opencode_extra_search_paths(&home, install_dir, xdg_bin_dir, gopath);
+
+        assert_eq!(paths[0], PathBuf::from("/custom/opencode/bin"));
+        assert_eq!(paths[1], PathBuf::from("/xdg/bin"));
+        assert!(paths.contains(&PathBuf::from("/home/tester/bin")));
+        assert!(paths.contains(&PathBuf::from("/home/tester/.opencode/bin")));
+        assert!(paths.contains(&PathBuf::from("/home/tester/go/bin")));
+        assert!(paths.contains(&PathBuf::from("/go/path1/bin")));
+        assert!(paths.contains(&PathBuf::from("/go/path2/bin")));
+    }
+
+    #[test]
+    fn opencode_extra_search_paths_deduplicates_repeated_entries() {
+        let home = PathBuf::from("/home/tester");
+        let same_dir = Some(std::ffi::OsString::from("/same/path"));
+
+        let paths = opencode_extra_search_paths(&home, same_dir.clone(), same_dir.clone(), None);
+
+        let count = paths
+            .iter()
+            .filter(|path| **path == PathBuf::from("/same/path"))
+            .count();
+        assert_eq!(count, 1);
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    #[test]
+    fn tool_executable_candidates_non_windows_uses_plain_binary_name() {
+        let dir = PathBuf::from("/usr/local/bin");
+        let candidates = tool_executable_candidates("opencode", &dir);
+
+        assert_eq!(candidates, vec![PathBuf::from("/usr/local/bin/opencode")]);
+    }
+
+    #[cfg(target_os = "windows")]
+    #[test]
+    fn tool_executable_candidates_windows_includes_cmd_exe_and_plain_name() {
+        let dir = PathBuf::from("C:\\tools");
+        let candidates = tool_executable_candidates("opencode", &dir);
+
+        assert_eq!(
+            candidates,
+            vec![
+                PathBuf::from("C:\\tools\\opencode.cmd"),
+                PathBuf::from("C:\\tools\\opencode.exe"),
+                PathBuf::from("C:\\tools\\opencode"),
+            ]
+        );
+    }
+}

src-tauri/src/commands/mod.rs

@@ -9,6 +9,7 @@ mod import_export;
 mod mcp;
 mod misc;
 mod omo;
+mod openclaw;
 mod plugin;
 mod prompt;
 mod provider;
@@ -17,7 +18,10 @@ mod session_manager;
 mod settings;
 pub mod skill;
 mod stream_check;
+mod sync_support;
 mod usage;
+mod webdav_sync;
+mod workspace;
 
 pub use config::*;
 pub use deeplink::*;
@@ -28,6 +32,7 @@ pub use import_export::*;
 pub use mcp::*;
 pub use misc::*;
 pub use omo::*;
+pub use openclaw::*;
 pub use plugin::*;
 pub use prompt::*;
 pub use provider::*;
@@ -37,3 +42,5 @@ pub use settings::*;
 pub use skill::*;
 pub use stream_check::*;
 pub use usage::*;
+pub use webdav_sync::*;
+pub use workspace::*;

src-tauri/src/commands/omo.rs

@@ -1,19 +1,19 @@
 use tauri::State;
 
-use crate::services::omo::OmoLocalFileData;
+use crate::services::omo::{OmoLocalFileData, SLIM, STANDARD};
 use crate::services::OmoService;
 use crate::store::AppState;
 
 #[tauri::command]
 pub async fn read_omo_local_file() -> Result<OmoLocalFileData, String> {
-    OmoService::read_local_file().map_err(|e| e.to_string())
+    OmoService::read_local_file(&STANDARD).map_err(|e| e.to_string())
 }
 
 #[tauri::command]
 pub async fn get_current_omo_provider_id(state: State<'_, AppState>) -> Result<String, String> {
     let provider = state
         .db
-        .get_current_omo_provider("opencode")
+        .get_current_omo_provider("opencode", "omo")
         .map_err(|e| e.to_string())?;
     Ok(provider.map(|p| p.id).unwrap_or_default())
 }
@@ -28,23 +28,46 @@ pub async fn disable_current_omo(state: State<'_, AppState>) -> Result<(), Strin
         if p.category.as_deref() == Some("omo") {
             state
                 .db
-                .clear_omo_provider_current("opencode", id)
+                .clear_omo_provider_current("opencode", id, "omo")
                 .map_err(|e| e.to_string())?;
         }
     }
-    OmoService::delete_config_file().map_err(|e| e.to_string())?;
+    OmoService::delete_config_file(&STANDARD).map_err(|e| e.to_string())?;
     Ok(())
 }
 
+// ── OMO Slim commands ───────────────────────────────────────
+
 #[tauri::command]
-pub async fn get_omo_provider_count(state: State<'_, AppState>) -> Result<usize, String> {
+pub async fn read_omo_slim_local_file() -> Result<OmoLocalFileData, String> {
+    OmoService::read_local_file(&SLIM).map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub async fn get_current_omo_slim_provider_id(
+    state: State<'_, AppState>,
+) -> Result<String, String> {
+    let provider = state
+        .db
+        .get_current_omo_provider("opencode", "omo-slim")
+        .map_err(|e| e.to_string())?;
+    Ok(provider.map(|p| p.id).unwrap_or_default())
+}
+
+#[tauri::command]
+pub async fn disable_current_omo_slim(state: State<'_, AppState>) -> Result<(), String> {
     let providers = state
         .db
         .get_all_providers("opencode")
         .map_err(|e| e.to_string())?;
-    let count = providers
-        .values()
-        .filter(|p| p.category.as_deref() == Some("omo"))
-        .count();
-    Ok(count)
+    for (id, p) in &providers {
+        if p.category.as_deref() == Some("omo-slim") {
+            state
+                .db
+                .clear_omo_provider_current("opencode", id, "omo-slim")
+                .map_err(|e| e.to_string())?;
+        }
+    }
+    OmoService::delete_config_file(&SLIM).map_err(|e| e.to_string())?;
+    Ok(())
 }

src-tauri/src/commands/openclaw.rs

@@ -0,0 +1,108 @@
+use std::collections::HashMap;
+use tauri::State;
+
+use crate::openclaw_config;
+use crate::store::AppState;
+
+// ============================================================================
+// OpenClaw Provider Commands (migrated from provider.rs)
+// ============================================================================
+
+/// Import providers from OpenClaw live config to database.
+///
+/// OpenClaw uses additive mode — users may already have providers
+/// configured in openclaw.json.
+#[tauri::command]
+pub fn import_openclaw_providers_from_live(state: State<'_, AppState>) -> Result<usize, String> {
+    crate::services::provider::import_openclaw_providers_from_live(state.inner())
+        .map_err(|e| e.to_string())
+}
+
+/// Get provider IDs in the OpenClaw live config.
+#[tauri::command]
+pub fn get_openclaw_live_provider_ids() -> Result<Vec<String>, String> {
+    openclaw_config::get_providers()
+        .map(|providers| providers.keys().cloned().collect())
+        .map_err(|e| e.to_string())
+}
+
+// ============================================================================
+// Agents Configuration Commands
+// ============================================================================
+
+/// Get OpenClaw default model config (agents.defaults.model)
+#[tauri::command]
+pub fn get_openclaw_default_model() -> Result<Option<openclaw_config::OpenClawDefaultModel>, String>
+{
+    openclaw_config::get_default_model().map_err(|e| e.to_string())
+}
+
+/// Set OpenClaw default model config (agents.defaults.model)
+#[tauri::command]
+pub fn set_openclaw_default_model(
+    model: openclaw_config::OpenClawDefaultModel,
+) -> Result<(), String> {
+    openclaw_config::set_default_model(&model).map_err(|e| e.to_string())
+}
+
+/// Get OpenClaw model catalog/allowlist (agents.defaults.models)
+#[tauri::command]
+pub fn get_openclaw_model_catalog(
+) -> Result<Option<HashMap<String, openclaw_config::OpenClawModelCatalogEntry>>, String> {
+    openclaw_config::get_model_catalog().map_err(|e| e.to_string())
+}
+
+/// Set OpenClaw model catalog/allowlist (agents.defaults.models)
+#[tauri::command]
+pub fn set_openclaw_model_catalog(
+    catalog: HashMap<String, openclaw_config::OpenClawModelCatalogEntry>,
+) -> Result<(), String> {
+    openclaw_config::set_model_catalog(&catalog).map_err(|e| e.to_string())
+}
+
+/// Get full agents.defaults config (all fields)
+#[tauri::command]
+pub fn get_openclaw_agents_defaults(
+) -> Result<Option<openclaw_config::OpenClawAgentsDefaults>, String> {
+    openclaw_config::get_agents_defaults().map_err(|e| e.to_string())
+}
+
+/// Set full agents.defaults config (all fields)
+#[tauri::command]
+pub fn set_openclaw_agents_defaults(
+    defaults: openclaw_config::OpenClawAgentsDefaults,
+) -> Result<(), String> {
+    openclaw_config::set_agents_defaults(&defaults).map_err(|e| e.to_string())
+}
+
+// ============================================================================
+// Env Configuration Commands
+// ============================================================================
+
+/// Get OpenClaw env config (env section of openclaw.json)
+#[tauri::command]
+pub fn get_openclaw_env() -> Result<openclaw_config::OpenClawEnvConfig, String> {
+    openclaw_config::get_env_config().map_err(|e| e.to_string())
+}
+
+/// Set OpenClaw env config (env section of openclaw.json)
+#[tauri::command]
+pub fn set_openclaw_env(env: openclaw_config::OpenClawEnvConfig) -> Result<(), String> {
+    openclaw_config::set_env_config(&env).map_err(|e| e.to_string())
+}
+
+// ============================================================================
+// Tools Configuration Commands
+// ============================================================================
+
+/// Get OpenClaw tools config (tools section of openclaw.json)
+#[tauri::command]
+pub fn get_openclaw_tools() -> Result<openclaw_config::OpenClawToolsConfig, String> {
+    openclaw_config::get_tools_config().map_err(|e| e.to_string())
+}
+
+/// Set OpenClaw tools config (tools section of openclaw.json)
+#[tauri::command]
+pub fn set_openclaw_tools(tools: openclaw_config::OpenClawToolsConfig) -> Result<(), String> {
+    openclaw_config::set_tools_config(&tools).map_err(|e| e.to_string())
+}

src-tauri/src/commands/provider.rs

@@ -4,7 +4,9 @@ use tauri::State;
 use crate::app_config::AppType;
 use crate::error::AppError;
 use crate::provider::Provider;
-use crate::services::{EndpointLatency, ProviderService, ProviderSortUpdate, SpeedtestService};
+use crate::services::{
+    EndpointLatency, ProviderService, ProviderSortUpdate, SpeedtestService, SwitchResult,
+};
 use crate::store::AppState;
 use std::str::FromStr;
 
@@ -67,7 +69,11 @@ pub fn remove_provider_from_live_config(
         .map_err(|e| e.to_string())
 }
 
-fn switch_provider_internal(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
+fn switch_provider_internal(
+    state: &AppState,
+    app_type: AppType,
+    id: &str,
+) -> Result<SwitchResult, AppError> {
     ProviderService::switch(state, app_type, id)
 }
 
@@ -76,7 +82,7 @@ pub fn switch_provider_test_hook(
     state: &AppState,
     app_type: AppType,
     id: &str,
-) -> Result<(), AppError> {
+) -> Result<SwitchResult, AppError> {
     switch_provider_internal(state, app_type, id)
 }
 
@@ -85,15 +91,35 @@ pub fn switch_provider(
     state: State<'_, AppState>,
     app: String,
     id: String,
-) -> Result<bool, String> {
+) -> Result<SwitchResult, String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
-    switch_provider_internal(&state, app_type, &id)
-        .map(|_| true)
-        .map_err(|e| e.to_string())
+    switch_provider_internal(&state, app_type, &id).map_err(|e| e.to_string())
 }
 
 fn import_default_config_internal(state: &AppState, app_type: AppType) -> Result<bool, AppError> {
-    ProviderService::import_default_config(state, app_type)
+    let imported = ProviderService::import_default_config(state, app_type.clone())?;
+
+    if imported {
+        // Extract common config snippet (mirrors old startup logic in lib.rs)
+        if state
+            .db
+            .get_config_snippet(app_type.as_str())
+            .ok()
+            .flatten()
+            .is_none()
+        {
+            match ProviderService::extract_common_config_snippet(state, app_type.clone()) {
+                Ok(snippet) if !snippet.is_empty() && snippet != "{}" => {
+                    let _ = state
+                        .db
+                        .set_config_snippet(app_type.as_str(), Some(snippet));
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Ok(imported)
 }
 
 #[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
@@ -318,3 +344,7 @@ pub fn get_opencode_live_provider_ids() -> Result<Vec<String>, String> {
         .map(|providers| providers.keys().cloned().collect())
         .map_err(|e| e.to_string())
 }
+
+// ============================================================================
+// OpenClaw 专属命令 → 已迁移至 commands/openclaw.rs
+// ============================================================================

src-tauri/src/commands/settings.rs

@@ -2,16 +2,28 @@
 
 use tauri::AppHandle;
 
+fn merge_settings_for_save(
+    mut incoming: crate::settings::AppSettings,
+    existing: &crate::settings::AppSettings,
+) -> crate::settings::AppSettings {
+    if incoming.webdav_sync.is_none() {
+        incoming.webdav_sync = existing.webdav_sync.clone();
+    }
+    incoming
+}
+
 /// 获取设置
 #[tauri::command]
 pub async fn get_settings() -> Result<crate::settings::AppSettings, String> {
-    Ok(crate::settings::get_settings())
+    Ok(crate::settings::get_settings_for_frontend())
 }
 
 /// 保存设置
 #[tauri::command]
 pub async fn save_settings(settings: crate::settings::AppSettings) -> Result<bool, String> {
-    crate::settings::update_settings(settings).map_err(|e| e.to_string())?;
+    let existing = crate::settings::get_settings();
+    let merged = merge_settings_for_save(settings, &existing);
+    crate::settings::update_settings(merged).map_err(|e| e.to_string())?;
     Ok(true)
 }
 
@@ -54,6 +66,58 @@ pub async fn set_auto_launch(enabled: bool) -> Result<bool, String> {
     Ok(true)
 }
 
+#[cfg(test)]
+mod tests {
+    use super::merge_settings_for_save;
+    use crate::settings::{AppSettings, WebDavSyncSettings};
+
+    #[test]
+    fn save_settings_should_preserve_existing_webdav_when_payload_omits_it() {
+        let mut existing = AppSettings::default();
+        existing.webdav_sync = Some(WebDavSyncSettings {
+            base_url: "https://dav.example.com".to_string(),
+            username: "alice".to_string(),
+            password: "secret".to_string(),
+            ..WebDavSyncSettings::default()
+        });
+
+        let incoming = AppSettings::default();
+        let merged = merge_settings_for_save(incoming, &existing);
+
+        assert!(merged.webdav_sync.is_some());
+        assert_eq!(
+            merged.webdav_sync.as_ref().map(|v| v.base_url.as_str()),
+            Some("https://dav.example.com")
+        );
+    }
+
+    #[test]
+    fn save_settings_should_keep_incoming_webdav_when_present() {
+        let mut existing = AppSettings::default();
+        existing.webdav_sync = Some(WebDavSyncSettings {
+            base_url: "https://dav.old.example.com".to_string(),
+            username: "old".to_string(),
+            password: "old-pass".to_string(),
+            ..WebDavSyncSettings::default()
+        });
+
+        let mut incoming = AppSettings::default();
+        incoming.webdav_sync = Some(WebDavSyncSettings {
+            base_url: "https://dav.new.example.com".to_string(),
+            username: "new".to_string(),
+            password: "new-pass".to_string(),
+            ..WebDavSyncSettings::default()
+        });
+
+        let merged = merge_settings_for_save(incoming, &existing);
+
+        assert_eq!(
+            merged.webdav_sync.as_ref().map(|v| v.base_url.as_str()),
+            Some("https://dav.new.example.com")
+        );
+    }
+}
+
 /// 获取开机自启状态
 #[tauri::command]
 pub async fn get_auto_launch_status() -> Result<bool, String> {

src-tauri/src/commands/sync_support.rs

@@ -0,0 +1,97 @@
+use serde_json::{json, Value};
+use std::sync::Arc;
+
+use crate::database::Database;
+use crate::error::AppError;
+use crate::services::provider::ProviderService;
+use crate::settings;
+use crate::store::AppState;
+
+pub(crate) fn run_post_import_sync(db: Arc<Database>) -> Result<(), AppError> {
+    let app_state = AppState::new(db);
+    ProviderService::sync_current_to_live(&app_state)?;
+    settings::reload_settings()?;
+    Ok(())
+}
+
+fn post_sync_warning<E: std::fmt::Display>(err: E) -> String {
+    AppError::localized(
+        "sync.post_operation_sync_failed",
+        format!("后置同步状态失败: {err}"),
+        format!("Post-operation synchronization failed: {err}"),
+    )
+    .to_string()
+}
+
+pub(crate) fn post_sync_warning_from_result(
+    result: Result<Result<(), AppError>, String>,
+) -> Option<String> {
+    match result {
+        Ok(Ok(())) => None,
+        Ok(Err(err)) => Some(post_sync_warning(err)),
+        Err(err) => Some(post_sync_warning(err)),
+    }
+}
+
+pub(crate) fn attach_warning(mut value: Value, warning: Option<String>) -> Value {
+    if let Some(message) = warning {
+        if let Some(obj) = value.as_object_mut() {
+            obj.insert("warning".to_string(), Value::String(message));
+        }
+    }
+    value
+}
+
+pub(crate) fn success_payload_with_warning(backup_id: String, warning: Option<String>) -> Value {
+    attach_warning(
+        json!({
+            "success": true,
+            "message": "SQL imported successfully",
+            "backupId": backup_id
+        }),
+        warning,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{attach_warning, post_sync_warning_from_result};
+    use serde_json::json;
+
+    #[test]
+    fn post_sync_warning_from_result_returns_none_on_success() {
+        let warning = post_sync_warning_from_result(Ok(Ok(())));
+        assert!(warning.is_none());
+    }
+
+    #[test]
+    fn post_sync_warning_from_result_returns_some_on_sync_error() {
+        let warning =
+            post_sync_warning_from_result(Ok(Err(crate::error::AppError::Config("boom".into()))));
+        assert!(warning.is_some());
+    }
+
+    #[tokio::test]
+    async fn post_sync_warning_from_result_returns_some_on_join_error() {
+        let handle = tokio::spawn(async move {
+            panic!("forced join error");
+        });
+        let join_err = handle.await.expect_err("task should panic");
+        let warning = post_sync_warning_from_result(Err(join_err.to_string()));
+        assert!(warning.is_some());
+    }
+
+    #[test]
+    fn attach_warning_adds_warning_without_dropping_existing_fields() {
+        let payload = json!({ "status": "downloaded" });
+        let updated = attach_warning(payload, Some("post sync warning".to_string()));
+        assert_eq!(
+            updated.get("status").and_then(|v| v.as_str()),
+            Some("downloaded")
+        );
+        assert_eq!(
+            updated.get("warning").and_then(|v| v.as_str()),
+            Some("post sync warning")
+        );
+    }
+}

src-tauri/src/commands/webdav_sync.rs

@@ -0,0 +1,357 @@
+#![allow(non_snake_case)]
+
+use serde_json::{json, Value};
+use tauri::State;
+
+use crate::commands::sync_support::{
+    attach_warning, post_sync_warning_from_result, run_post_import_sync,
+};
+use crate::error::AppError;
+use crate::services::webdav_sync as webdav_sync_service;
+use crate::settings::{self, WebDavSyncSettings};
+use crate::store::AppState;
+
+fn persist_sync_error(settings: &mut WebDavSyncSettings, error: &AppError, source: &str) {
+    settings.status.last_error = Some(error.to_string());
+    settings.status.last_error_source = Some(source.to_string());
+    let _ = settings::update_webdav_sync_status(settings.status.clone());
+}
+
+fn webdav_not_configured_error() -> String {
+    AppError::localized(
+        "webdav.sync.not_configured",
+        "未配置 WebDAV 同步",
+        "WebDAV sync is not configured.",
+    )
+    .to_string()
+}
+
+fn webdav_sync_disabled_error() -> String {
+    AppError::localized(
+        "webdav.sync.disabled",
+        "WebDAV 同步未启用",
+        "WebDAV sync is disabled.",
+    )
+    .to_string()
+}
+
+fn require_enabled_webdav_settings() -> Result<WebDavSyncSettings, String> {
+    let settings = settings::get_webdav_sync_settings().ok_or_else(webdav_not_configured_error)?;
+    if !settings.enabled {
+        return Err(webdav_sync_disabled_error());
+    }
+    Ok(settings)
+}
+
+fn resolve_password_for_request(
+    mut incoming: WebDavSyncSettings,
+    existing: Option<WebDavSyncSettings>,
+    preserve_empty_password: bool,
+) -> WebDavSyncSettings {
+    if let Some(existing_settings) = existing {
+        if preserve_empty_password && incoming.password.is_empty() {
+            incoming.password = existing_settings.password;
+        }
+    }
+    incoming
+}
+
+#[cfg(test)]
+fn webdav_sync_mutex() -> &'static tokio::sync::Mutex<()> {
+    webdav_sync_service::sync_mutex()
+}
+
+async fn run_with_webdav_lock<T, Fut>(operation: Fut) -> Result<T, AppError>
+where
+    Fut: std::future::Future<Output = Result<T, AppError>>,
+{
+    webdav_sync_service::run_with_sync_lock(operation).await
+}
+
+fn map_sync_result<T, F>(result: Result<T, AppError>, on_error: F) -> Result<T, String>
+where
+    F: FnOnce(&AppError),
+{
+    match result {
+        Ok(value) => Ok(value),
+        Err(err) => {
+            on_error(&err);
+            Err(err.to_string())
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn webdav_test_connection(
+    settings: WebDavSyncSettings,
+    #[allow(non_snake_case)] preserveEmptyPassword: Option<bool>,
+) -> Result<Value, String> {
+    let preserve_empty = preserveEmptyPassword.unwrap_or(true);
+    let resolved = resolve_password_for_request(
+        settings,
+        settings::get_webdav_sync_settings(),
+        preserve_empty,
+    );
+    webdav_sync_service::check_connection(&resolved)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(json!({
+        "success": true,
+        "message": "WebDAV connection ok"
+    }))
+}
+
+#[tauri::command]
+pub async fn webdav_sync_upload(state: State<'_, AppState>) -> Result<Value, String> {
+    let db = state.db.clone();
+    let mut settings = require_enabled_webdav_settings()?;
+
+    let result = run_with_webdav_lock(webdav_sync_service::upload(&db, &mut settings)).await;
+    map_sync_result(result, |error| {
+        persist_sync_error(&mut settings, error, "manual")
+    })
+}
+
+#[tauri::command]
+pub async fn webdav_sync_download(state: State<'_, AppState>) -> Result<Value, String> {
+    let db = state.db.clone();
+    let db_for_sync = db.clone();
+    let mut settings = require_enabled_webdav_settings()?;
+    let _auto_sync_suppression = crate::services::webdav_auto_sync::AutoSyncSuppressionGuard::new();
+
+    let sync_result = run_with_webdav_lock(webdav_sync_service::download(&db, &mut settings)).await;
+    let mut result = map_sync_result(sync_result, |error| {
+        persist_sync_error(&mut settings, error, "manual")
+    })?;
+
+    // Post-download sync is best-effort: snapshot restore has already succeeded.
+    let warning = post_sync_warning_from_result(
+        tauri::async_runtime::spawn_blocking(move || run_post_import_sync(db_for_sync))
+            .await
+            .map_err(|e| e.to_string()),
+    );
+    if let Some(msg) = warning.as_ref() {
+        log::warn!("[WebDAV] post-download sync warning: {msg}");
+    }
+    result = attach_warning(result, warning);
+
+    Ok(result)
+}
+
+#[tauri::command]
+pub async fn webdav_sync_save_settings(
+    settings: WebDavSyncSettings,
+    #[allow(non_snake_case)] passwordTouched: Option<bool>,
+) -> Result<Value, String> {
+    let password_touched = passwordTouched.unwrap_or(false);
+    let existing = settings::get_webdav_sync_settings();
+    let mut sync_settings =
+        resolve_password_for_request(settings, existing.clone(), !password_touched);
+
+    // Preserve server-owned fields that the frontend does not manage
+    if let Some(existing_settings) = existing {
+        sync_settings.status = existing_settings.status;
+    }
+
+    sync_settings.normalize();
+    sync_settings.validate().map_err(|e| e.to_string())?;
+    settings::set_webdav_sync_settings(Some(sync_settings)).map_err(|e| e.to_string())?;
+    Ok(json!({ "success": true }))
+}
+
+#[tauri::command]
+pub async fn webdav_sync_fetch_remote_info() -> Result<Value, String> {
+    let settings = require_enabled_webdav_settings()?;
+    let info = webdav_sync_service::fetch_remote_info(&settings)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(info.unwrap_or(json!({ "empty": true })))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        map_sync_result, persist_sync_error, require_enabled_webdav_settings,
+        resolve_password_for_request, run_with_webdav_lock, webdav_sync_mutex,
+    };
+    use crate::error::AppError;
+    use crate::settings::{AppSettings, WebDavSyncSettings};
+    use serial_test::serial;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    #[tokio::test]
+    async fn webdav_sync_mutex_is_singleton() {
+        let a = webdav_sync_mutex() as *const _;
+        let b = webdav_sync_mutex() as *const _;
+        assert_eq!(a, b);
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn webdav_sync_mutex_serializes_concurrent_access() {
+        let guard = webdav_sync_mutex().lock().await;
+        let acquired = Arc::new(AtomicBool::new(false));
+        let acquired_bg = Arc::clone(&acquired);
+
+        let waiter = tokio::spawn(async move {
+            let _inner_guard = webdav_sync_mutex().lock().await;
+            acquired_bg.store(true, Ordering::SeqCst);
+        });
+
+        tokio::time::sleep(Duration::from_millis(40)).await;
+        assert!(!acquired.load(Ordering::SeqCst));
+
+        drop(guard);
+        tokio::time::timeout(Duration::from_secs(1), waiter)
+            .await
+            .expect("background task should complete after lock release")
+            .expect("background task should not panic");
+
+        assert!(acquired.load(Ordering::SeqCst));
+    }
+
+    #[tokio::test]
+    #[serial]
+    async fn map_sync_result_runs_error_handler_after_lock_release() {
+        let result = run_with_webdav_lock(async {
+            Err::<(), AppError>(AppError::Config("boom".to_string()))
+        })
+        .await;
+
+        let mut lock_released = false;
+        let mapped = map_sync_result(result, |_| {
+            lock_released = webdav_sync_mutex().try_lock().is_ok();
+        });
+
+        assert!(mapped.is_err());
+        assert!(lock_released);
+    }
+
+    #[test]
+    fn resolve_password_for_request_preserves_existing_when_requested() {
+        let incoming = WebDavSyncSettings {
+            base_url: "https://dav.example.com".to_string(),
+            username: "alice".to_string(),
+            password: String::new(),
+            ..WebDavSyncSettings::default()
+        };
+        let existing = Some(WebDavSyncSettings {
+            password: "secret".to_string(),
+            ..WebDavSyncSettings::default()
+        });
+        let resolved = resolve_password_for_request(incoming, existing, true);
+        assert_eq!(resolved.password, "secret");
+    }
+
+    #[test]
+    fn resolve_password_for_request_allows_explicit_empty_password() {
+        let incoming = WebDavSyncSettings {
+            base_url: "https://dav.example.com".to_string(),
+            username: "alice".to_string(),
+            password: String::new(),
+            ..WebDavSyncSettings::default()
+        };
+        let existing = Some(WebDavSyncSettings {
+            password: "secret".to_string(),
+            ..WebDavSyncSettings::default()
+        });
+        let resolved = resolve_password_for_request(incoming, existing, false);
+        assert!(resolved.password.is_empty());
+    }
+
+    #[test]
+    #[serial]
+    fn persist_sync_error_updates_status_without_overwriting_credentials() {
+        let test_home = std::env::temp_dir().join("cc-switch-sync-error-status-test");
+        let _ = std::fs::remove_dir_all(&test_home);
+        std::fs::create_dir_all(&test_home).expect("create test home");
+        std::env::set_var("CC_SWITCH_TEST_HOME", &test_home);
+
+        crate::settings::update_settings(AppSettings::default()).expect("reset settings");
+        let mut current = WebDavSyncSettings {
+            enabled: true,
+            base_url: "https://dav.example.com/dav/".to_string(),
+            username: "alice".to_string(),
+            password: "secret".to_string(),
+            remote_root: "cc-switch-sync".to_string(),
+            profile: "default".to_string(),
+            ..WebDavSyncSettings::default()
+        };
+        crate::settings::set_webdav_sync_settings(Some(current.clone()))
+            .expect("seed webdav settings");
+
+        persist_sync_error(
+            &mut current,
+            &crate::error::AppError::Config("boom".to_string()),
+            "manual",
+        );
+
+        let after = crate::settings::get_webdav_sync_settings().expect("read webdav settings");
+        assert_eq!(after.base_url, "https://dav.example.com/dav/");
+        assert_eq!(after.username, "alice");
+        assert_eq!(after.password, "secret");
+        assert_eq!(after.remote_root, "cc-switch-sync");
+        assert_eq!(after.profile, "default");
+        assert!(
+            after
+                .status
+                .last_error
+                .as_deref()
+                .unwrap_or_default()
+                .contains("boom"),
+            "status error should be updated"
+        );
+        assert_eq!(after.status.last_error_source.as_deref(), Some("manual"));
+    }
+
+    #[test]
+    #[serial]
+    fn require_enabled_webdav_settings_rejects_disabled_config() {
+        let test_home = std::env::temp_dir().join("cc-switch-sync-enabled-disabled-test");
+        let _ = std::fs::remove_dir_all(&test_home);
+        std::fs::create_dir_all(&test_home).expect("create test home");
+        std::env::set_var("CC_SWITCH_TEST_HOME", &test_home);
+
+        crate::settings::update_settings(AppSettings::default()).expect("reset settings");
+        crate::settings::set_webdav_sync_settings(Some(WebDavSyncSettings {
+            enabled: false,
+            base_url: "https://dav.example.com/dav/".to_string(),
+            username: "alice".to_string(),
+            password: "secret".to_string(),
+            ..WebDavSyncSettings::default()
+        }))
+        .expect("seed disabled webdav settings");
+
+        let err = require_enabled_webdav_settings().expect_err("disabled settings should fail");
+        assert!(
+            err.contains("disabled") || err.contains("未启用"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    #[serial]
+    fn require_enabled_webdav_settings_returns_settings_when_enabled() {
+        let test_home = std::env::temp_dir().join("cc-switch-sync-enabled-ok-test");
+        let _ = std::fs::remove_dir_all(&test_home);
+        std::fs::create_dir_all(&test_home).expect("create test home");
+        std::env::set_var("CC_SWITCH_TEST_HOME", &test_home);
+
+        crate::settings::update_settings(AppSettings::default()).expect("reset settings");
+        crate::settings::set_webdav_sync_settings(Some(WebDavSyncSettings {
+            enabled: true,
+            base_url: "https://dav.example.com/dav/".to_string(),
+            username: "alice".to_string(),
+            password: "secret".to_string(),
+            ..WebDavSyncSettings::default()
+        }))
+        .expect("seed enabled webdav settings");
+
+        let settings =
+            require_enabled_webdav_settings().expect("enabled settings should be accepted");
+        assert!(settings.enabled);
+        assert_eq!(settings.base_url, "https://dav.example.com/dav/");
+    }
+}

src-tauri/src/commands/workspace.rs

@@ -0,0 +1,362 @@
+use regex::Regex;
+use std::sync::LazyLock;
+use tauri::AppHandle;
+use tauri_plugin_opener::OpenerExt;
+
+use crate::config::write_text_file;
+use crate::openclaw_config::get_openclaw_dir;
+
+/// Allowed workspace filenames (whitelist for security)
+const ALLOWED_FILES: &[&str] = &[
+    "AGENTS.md",
+    "SOUL.md",
+    "USER.md",
+    "IDENTITY.md",
+    "TOOLS.md",
+    "MEMORY.md",
+    "HEARTBEAT.md",
+    "BOOTSTRAP.md",
+    "BOOT.md",
+];
+
+fn validate_filename(filename: &str) -> Result<(), String> {
+    if !ALLOWED_FILES.contains(&filename) {
+        return Err(format!(
+            "Invalid workspace filename: {filename}. Allowed: {}",
+            ALLOWED_FILES.join(", ")
+        ));
+    }
+    Ok(())
+}
+
+// --- Daily memory files (memory/YYYY-MM-DD.md) ---
+
+static DAILY_MEMORY_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^\d{4}-\d{2}-\d{2}\.md$").unwrap());
+
+fn validate_daily_memory_filename(filename: &str) -> Result<(), String> {
+    if !DAILY_MEMORY_RE.is_match(filename) {
+        return Err(format!(
+            "Invalid daily memory filename: {filename}. Expected: YYYY-MM-DD.md"
+        ));
+    }
+    Ok(())
+}
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DailyMemoryFileInfo {
+    pub filename: String,
+    pub date: String,
+    pub size_bytes: u64,
+    pub modified_at: u64,
+    pub preview: String,
+}
+
+// --- Daily memory commands ---
+
+/// List all daily memory files under `workspace/memory/`.
+#[tauri::command]
+pub async fn list_daily_memory_files() -> Result<Vec<DailyMemoryFileInfo>, String> {
+    let memory_dir = get_openclaw_dir().join("workspace").join("memory");
+
+    if !memory_dir.exists() {
+        return Ok(Vec::new());
+    }
+
+    let mut files: Vec<DailyMemoryFileInfo> = Vec::new();
+
+    let entries = std::fs::read_dir(&memory_dir)
+        .map_err(|e| format!("Failed to read memory directory: {e}"))?;
+
+    for entry in entries.flatten() {
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".md") {
+            continue;
+        }
+
+        let meta = match entry.metadata() {
+            Ok(m) => m,
+            Err(_) => continue,
+        };
+        if !meta.is_file() {
+            continue;
+        }
+
+        let date = name.trim_end_matches(".md").to_string();
+
+        let size_bytes = meta.len();
+        let modified_at = meta
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+
+        let preview = std::fs::read_to_string(entry.path())
+            .unwrap_or_default()
+            .chars()
+            .take(200)
+            .collect::<String>();
+
+        files.push(DailyMemoryFileInfo {
+            filename: name,
+            date,
+            size_bytes,
+            modified_at,
+            preview,
+        });
+    }
+
+    // Sort by filename descending (newest date first, YYYY-MM-DD.md)
+    files.sort_by(|a, b| b.filename.cmp(&a.filename));
+
+    Ok(files)
+}
+
+/// Read a daily memory file.
+#[tauri::command]
+pub async fn read_daily_memory_file(filename: String) -> Result<Option<String>, String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let path = get_openclaw_dir()
+        .join("workspace")
+        .join("memory")
+        .join(&filename);
+
+    if !path.exists() {
+        return Ok(None);
+    }
+
+    std::fs::read_to_string(&path)
+        .map(Some)
+        .map_err(|e| format!("Failed to read daily memory file {filename}: {e}"))
+}
+
+/// Write a daily memory file (atomic write).
+#[tauri::command]
+pub async fn write_daily_memory_file(filename: String, content: String) -> Result<(), String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let memory_dir = get_openclaw_dir().join("workspace").join("memory");
+
+    std::fs::create_dir_all(&memory_dir)
+        .map_err(|e| format!("Failed to create memory directory: {e}"))?;
+
+    let path = memory_dir.join(&filename);
+
+    write_text_file(&path, &content)
+        .map_err(|e| format!("Failed to write daily memory file {filename}: {e}"))
+}
+
+/// Find the largest index `<= i` that is a valid UTF-8 char boundary.
+/// Equivalent to the unstable `str::floor_char_boundary` (stabilized in 1.91).
+fn floor_char_boundary(s: &str, mut i: usize) -> usize {
+    if i >= s.len() {
+        return s.len();
+    }
+    while !s.is_char_boundary(i) {
+        i -= 1;
+    }
+    i
+}
+
+/// Find the smallest index `>= i` that is a valid UTF-8 char boundary.
+/// Equivalent to the unstable `str::ceil_char_boundary` (stabilized in 1.91).
+fn ceil_char_boundary(s: &str, mut i: usize) -> usize {
+    if i >= s.len() {
+        return s.len();
+    }
+    while !s.is_char_boundary(i) {
+        i += 1;
+    }
+    i
+}
+
+/// Search result for daily memory full-text search.
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DailyMemorySearchResult {
+    pub filename: String,
+    pub date: String,
+    pub size_bytes: u64,
+    pub modified_at: u64,
+    pub snippet: String,
+    pub match_count: usize,
+}
+
+/// Full-text search across all daily memory files.
+///
+/// Performs case-insensitive search on both the date field and file content.
+/// Returns results sorted by filename descending (newest first), each with a
+/// snippet showing ~120 characters of context around the first match.
+#[tauri::command]
+pub async fn search_daily_memory_files(
+    query: String,
+) -> Result<Vec<DailyMemorySearchResult>, String> {
+    let memory_dir = get_openclaw_dir().join("workspace").join("memory");
+
+    if !memory_dir.exists() || query.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let query_lower = query.to_lowercase();
+    let mut results: Vec<DailyMemorySearchResult> = Vec::new();
+
+    let entries = std::fs::read_dir(&memory_dir)
+        .map_err(|e| format!("Failed to read memory directory: {e}"))?;
+
+    for entry in entries.flatten() {
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".md") {
+            continue;
+        }
+        let meta = match entry.metadata() {
+            Ok(m) if m.is_file() => m,
+            _ => continue,
+        };
+
+        let date = name.trim_end_matches(".md").to_string();
+        let content = std::fs::read_to_string(entry.path()).unwrap_or_default();
+        let content_lower = content.to_lowercase();
+
+        // Count matches in content
+        let content_matches: Vec<usize> = content_lower
+            .match_indices(&query_lower)
+            .map(|(i, _)| i)
+            .collect();
+
+        // Also check date field
+        let date_matches = date.to_lowercase().contains(&query_lower);
+
+        if content_matches.is_empty() && !date_matches {
+            continue;
+        }
+
+        // Build snippet around first content match (~120 chars of context)
+        let snippet = if let Some(&first_pos) = content_matches.first() {
+            let start = if first_pos > 50 {
+                floor_char_boundary(&content, first_pos - 50)
+            } else {
+                0
+            };
+            let end = ceil_char_boundary(&content, (first_pos + 70).min(content.len()));
+            let mut s = String::new();
+            if start > 0 {
+                s.push_str("...");
+            }
+            s.push_str(&content[start..end]);
+            if end < content.len() {
+                s.push_str("...");
+            }
+            s
+        } else {
+            // Date-only match — use beginning of file as preview
+            let end = ceil_char_boundary(&content, 120.min(content.len()));
+            let mut s = content[..end].to_string();
+            if end < content.len() {
+                s.push_str("...");
+            }
+            s
+        };
+
+        let size_bytes = meta.len();
+        let modified_at = meta
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+
+        results.push(DailyMemorySearchResult {
+            filename: name,
+            date,
+            size_bytes,
+            modified_at,
+            snippet,
+            match_count: content_matches.len(),
+        });
+    }
+
+    // Sort by filename descending (newest date first)
+    results.sort_by(|a, b| b.filename.cmp(&a.filename));
+
+    Ok(results)
+}
+
+/// Delete a daily memory file (idempotent).
+#[tauri::command]
+pub async fn delete_daily_memory_file(filename: String) -> Result<(), String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let path = get_openclaw_dir()
+        .join("workspace")
+        .join("memory")
+        .join(&filename);
+
+    if path.exists() {
+        std::fs::remove_file(&path)
+            .map_err(|e| format!("Failed to delete daily memory file {filename}: {e}"))?;
+    }
+
+    Ok(())
+}
+
+// --- Workspace file commands ---
+
+/// Read an OpenClaw workspace file content.
+/// Returns None if the file does not exist.
+#[tauri::command]
+pub async fn read_workspace_file(filename: String) -> Result<Option<String>, String> {
+    validate_filename(&filename)?;
+
+    let path = get_openclaw_dir().join("workspace").join(&filename);
+
+    if !path.exists() {
+        return Ok(None);
+    }
+
+    std::fs::read_to_string(&path)
+        .map(Some)
+        .map_err(|e| format!("Failed to read workspace file {filename}: {e}"))
+}
+
+/// Write content to an OpenClaw workspace file (atomic write).
+/// Creates the workspace directory if it does not exist.
+#[tauri::command]
+pub async fn write_workspace_file(filename: String, content: String) -> Result<(), String> {
+    validate_filename(&filename)?;
+
+    let workspace_dir = get_openclaw_dir().join("workspace");
+
+    // Ensure workspace directory exists
+    std::fs::create_dir_all(&workspace_dir)
+        .map_err(|e| format!("Failed to create workspace directory: {e}"))?;
+
+    let path = workspace_dir.join(&filename);
+
+    write_text_file(&path, &content)
+        .map_err(|e| format!("Failed to write workspace file {filename}: {e}"))
+}
+
+/// Open the workspace or memory directory in the system file manager.
+/// `subdir`: "workspace" opens `~/.openclaw/workspace/`,
+///           "memory" opens `~/.openclaw/workspace/memory/`.
+#[tauri::command]
+pub async fn open_workspace_directory(handle: AppHandle, subdir: String) -> Result<bool, String> {
+    let dir = match subdir.as_str() {
+        "memory" => get_openclaw_dir().join("workspace").join("memory"),
+        _ => get_openclaw_dir().join("workspace"),
+    };
+
+    if !dir.exists() {
+        std::fs::create_dir_all(&dir).map_err(|e| format!("Failed to create directory: {e}"))?;
+    }
+
+    handle
+        .opener()
+        .open_path(dir.to_string_lossy().to_string(), None::<String>)
+        .map_err(|e| format!("Failed to open directory: {e}"))?;
+
+    Ok(true)
+}

src-tauri/src/database/backup.rs

@@ -2,10 +2,10 @@
 //!
 //! 提供 SQL 导出/导入和二进制快照备份功能。
 
-use super::{lock_conn, Database, DB_BACKUP_RETAIN};
+use super::{lock_conn, Database};
 use crate::config::get_app_config_dir;
 use crate::error::AppError;
-use chrono::Utc;
+use chrono::{Local, Utc};
 use rusqlite::backup::Backup;
 use rusqlite::types::ValueRef;
 use rusqlite::Connection;
@@ -15,11 +15,25 @@ use tempfile::NamedTempFile;
 
 const CC_SWITCH_SQL_EXPORT_HEADER: &str = "-- CC Switch SQLite 导出";
 
+/// A database backup entry for the UI
+#[derive(Debug, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackupEntry {
+    pub filename: String,
+    pub size_bytes: u64,
+    pub created_at: String, // ISO 8601
+}
+
 impl Database {
+    /// 导出为 SQLite 兼容的 SQL 文本（内存字符串）
+    pub fn export_sql_string(&self) -> Result<String, AppError> {
+        let snapshot = self.snapshot_to_memory()?;
+        Self::dump_sql(&snapshot)
+    }
+
     /// 导出为 SQLite 兼容的 SQL 文本
     pub fn export_sql(&self, target_path: &Path) -> Result<(), AppError> {
-        let snapshot = self.snapshot_to_memory()?;
-        let dump = Self::dump_sql(&snapshot)?;
+        let dump = self.export_sql_string()?;
 
         if let Some(parent) = target_path.parent() {
             fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
@@ -38,6 +52,12 @@ impl Database {
         }
 
         let sql_raw = fs::read_to_string(source_path).map_err(|e| AppError::io(source_path, e))?;
+        let sql_content = sql_raw.trim_start_matches('\u{feff}');
+        self.import_sql_string(sql_content)
+    }
+
+    /// 从 SQL 字符串导入，返回生成的备份 ID（若无备份则为空字符串）
+    pub fn import_sql_string(&self, sql_raw: &str) -> Result<String, AppError> {
         let sql_content = sql_raw.trim_start_matches('\u{feff}');
         Self::validate_cc_switch_sql_export(sql_content)?;
 
@@ -109,8 +129,47 @@ impl Database {
         ))
     }
 
+    /// Periodic backup: create a new backup if the latest one is older than the configured interval
+    pub(crate) fn periodic_backup_if_needed(&self) -> Result<(), AppError> {
+        let interval_hours = crate::settings::effective_backup_interval_hours();
+        if interval_hours == 0 {
+            return Ok(()); // Auto-backup disabled
+        }
+
+        let backup_dir = get_app_config_dir().join("backups");
+        if !backup_dir.exists() {
+            self.backup_database_file()?;
+            return Ok(());
+        }
+
+        let latest = fs::read_dir(&backup_dir).ok().and_then(|entries| {
+            entries
+                .filter_map(|e| e.ok())
+                .filter(|e| e.path().extension().map(|ext| ext == "db").unwrap_or(false))
+                .filter_map(|e| e.metadata().ok().and_then(|m| m.modified().ok()))
+                .max()
+        });
+
+        let interval_secs = u64::from(interval_hours) * 3600;
+        let needs_backup = match latest {
+            None => true,
+            Some(last_modified) => {
+                last_modified.elapsed().unwrap_or_default()
+                    > std::time::Duration::from_secs(interval_secs)
+            }
+        };
+
+        if needs_backup {
+            log::info!(
+                "Periodic backup: latest backup is older than {interval_hours} hours, creating new backup"
+            );
+            self.backup_database_file()?;
+        }
+        Ok(())
+    }
+
     /// 生成一致性快照备份，返回备份文件路径（不存在主库时返回 None）
-    fn backup_database_file(&self) -> Result<Option<PathBuf>, AppError> {
+    pub(crate) fn backup_database_file(&self) -> Result<Option<PathBuf>, AppError> {
         let db_path = get_app_config_dir().join("cc-switch.db");
         if !db_path.exists() {
             return Ok(None);
@@ -123,7 +182,7 @@ impl Database {
 
         fs::create_dir_all(&backup_dir).map_err(|e| AppError::io(&backup_dir, e))?;
 
-        let base_id = format!("db_backup_{}", Utc::now().format("%Y%m%d_%H%M%S"));
+        let base_id = format!("db_backup_{}", Local::now().format("%Y%m%d_%H%M%S"));
         let mut backup_id = base_id.clone();
         let mut backup_path = backup_dir.join(format!("{backup_id}.db"));
         let mut counter = 1;
@@ -150,6 +209,7 @@ impl Database {
 
     /// 清理旧的数据库备份，保留最新的 N 个
     fn cleanup_db_backups(dir: &Path) -> Result<(), AppError> {
+        let retain = crate::settings::effective_backup_retain_count();
         let entries = match fs::read_dir(dir) {
             Ok(iter) => iter
                 .filter_map(|entry| entry.ok())
@@ -164,11 +224,11 @@ impl Database {
             Err(_) => return Ok(()),
         };
 
-        if entries.len() <= DB_BACKUP_RETAIN {
+        if entries.len() <= retain {
             return Ok(());
         }
 
-        let remove_count = entries.len().saturating_sub(DB_BACKUP_RETAIN);
+        let remove_count = entries.len().saturating_sub(retain);
         let mut sorted = entries;
         sorted.sort_by_key(|entry| entry.metadata().and_then(|m| m.modified()).ok());
 
@@ -322,4 +382,178 @@ impl Database {
             }
         }
     }
+
+    /// List all database backup files, sorted by creation time (newest first)
+    pub fn list_backups() -> Result<Vec<BackupEntry>, AppError> {
+        let backup_dir = get_app_config_dir().join("backups");
+        if !backup_dir.exists() {
+            return Ok(vec![]);
+        }
+
+        let mut entries: Vec<BackupEntry> = fs::read_dir(&backup_dir)
+            .map_err(|e| AppError::io(&backup_dir, e))?
+            .filter_map(|e| e.ok())
+            .filter(|e| e.path().extension().map(|ext| ext == "db").unwrap_or(false))
+            .filter_map(|e| {
+                let metadata = e.metadata().ok()?;
+                let filename = e.file_name().to_string_lossy().to_string();
+                let size_bytes = metadata.len();
+                let created_at = metadata
+                    .modified()
+                    .ok()
+                    .map(|t| {
+                        let dt: chrono::DateTime<Utc> = t.into();
+                        dt.to_rfc3339()
+                    })
+                    .unwrap_or_default();
+                Some(BackupEntry {
+                    filename,
+                    size_bytes,
+                    created_at,
+                })
+            })
+            .collect();
+
+        // Sort by created_at descending (newest first)
+        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        Ok(entries)
+    }
+
+    /// Restore database from a backup file. Returns the safety backup ID.
+    pub fn restore_from_backup(&self, filename: &str) -> Result<String, AppError> {
+        // Security: validate filename to prevent path traversal
+        if filename.contains("..")
+            || filename.contains('/')
+            || filename.contains('\\')
+            || !filename.ends_with(".db")
+        {
+            return Err(AppError::InvalidInput(
+                "Invalid backup filename".to_string(),
+            ));
+        }
+
+        let backup_dir = get_app_config_dir().join("backups");
+        let backup_path = backup_dir.join(filename);
+
+        if !backup_path.exists() {
+            return Err(AppError::InvalidInput(format!(
+                "Backup file not found: {filename}"
+            )));
+        }
+
+        // Step 1: Create safety backup of current database
+        let safety_backup = self.backup_database_file()?;
+        let safety_id = safety_backup
+            .and_then(|p| p.file_stem().map(|s| s.to_string_lossy().to_string()))
+            .unwrap_or_default();
+
+        // Step 2: Open the backup file and restore it to the main database
+        let source_conn =
+            Connection::open(&backup_path).map_err(|e| AppError::Database(e.to_string()))?;
+
+        {
+            let mut main_conn = lock_conn!(self.conn);
+            let backup = Backup::new(&source_conn, &mut main_conn)
+                .map_err(|e| AppError::Database(e.to_string()))?;
+            backup
+                .step(-1)
+                .map_err(|e| AppError::Database(e.to_string()))?;
+        }
+
+        // Step 3: Run schema migrations (backup may be from an older version)
+        self.create_tables()?;
+        self.apply_schema_migrations()?;
+        self.ensure_model_pricing_seeded()?;
+
+        log::info!("Database restored from backup: {filename}, safety backup: {safety_id}");
+        Ok(safety_id)
+    }
+
+    /// Rename a backup file. Returns the new filename.
+    pub fn rename_backup(old_filename: &str, new_name: &str) -> Result<String, AppError> {
+        // Validate old filename (path traversal + .db suffix)
+        if old_filename.contains("..")
+            || old_filename.contains('/')
+            || old_filename.contains('\\')
+            || !old_filename.ends_with(".db")
+        {
+            return Err(AppError::InvalidInput(
+                "Invalid backup filename".to_string(),
+            ));
+        }
+
+        // Clean new name
+        let trimmed = new_name.trim();
+        if trimmed.is_empty() {
+            return Err(AppError::InvalidInput(
+                "New name cannot be empty".to_string(),
+            ));
+        }
+
+        // Length limit (without .db suffix)
+        let name_part = trimmed.strip_suffix(".db").unwrap_or(trimmed);
+        if name_part.len() > 100 {
+            return Err(AppError::InvalidInput(
+                "Name too long (max 100 characters)".to_string(),
+            ));
+        }
+
+        // Prevent path traversal in new name
+        if name_part.contains("..")
+            || name_part.contains('/')
+            || name_part.contains('\\')
+            || name_part.contains('\0')
+        {
+            return Err(AppError::InvalidInput(
+                "Invalid characters in new name".to_string(),
+            ));
+        }
+
+        let new_filename = format!("{name_part}.db");
+
+        let backup_dir = get_app_config_dir().join("backups");
+        let old_path = backup_dir.join(old_filename);
+        let new_path = backup_dir.join(&new_filename);
+
+        if !old_path.exists() {
+            return Err(AppError::InvalidInput(format!(
+                "Backup file not found: {old_filename}"
+            )));
+        }
+
+        if new_path.exists() {
+            return Err(AppError::InvalidInput(format!(
+                "A backup named '{new_filename}' already exists"
+            )));
+        }
+
+        fs::rename(&old_path, &new_path).map_err(|e| AppError::io(&old_path, e))?;
+        log::info!("Renamed backup: {old_filename} -> {new_filename}");
+        Ok(new_filename)
+    }
+
+    /// Delete a backup file permanently.
+    pub fn delete_backup(filename: &str) -> Result<(), AppError> {
+        // Validate filename (path traversal + .db suffix)
+        if filename.contains("..")
+            || filename.contains('/')
+            || filename.contains('\\')
+            || !filename.ends_with(".db")
+        {
+            return Err(AppError::InvalidInput(
+                "Invalid backup filename".to_string(),
+            ));
+        }
+
+        let backup_path = get_app_config_dir().join("backups").join(filename);
+        if !backup_path.exists() {
+            return Err(AppError::InvalidInput(format!(
+                "Backup file not found: {filename}"
+            )));
+        }
+
+        fs::remove_file(&backup_path).map_err(|e| AppError::io(&backup_path, e))?;
+        log::info!("Deleted backup: {filename}");
+        Ok(())
+    }
 }

src-tauri/src/database/dao/mod.rs

@@ -4,7 +4,6 @@
 
 pub mod failover;
 pub mod mcp;
-pub mod omo;
 pub mod prompts;
 pub mod providers;
 pub mod proxy;
@@ -16,4 +15,3 @@ pub mod universal_providers;
 // 所有 DAO 方法都通过 Database impl 提供，无需单独导出
 // 导出 FailoverQueueItem 供外部使用
 pub use failover::FailoverQueueItem;
-pub use omo::OmoGlobalConfig;

src-tauri/src/database/dao/omo.rs

@@ -1,73 +0,0 @@
-use crate::database::Database;
-use crate::error::AppError;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct OmoGlobalConfig {
-    pub id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub schema_url: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sisyphus_agent: Option<serde_json::Value>,
-    #[serde(default)]
-    pub disabled_agents: Vec<String>,
-    #[serde(default)]
-    pub disabled_mcps: Vec<String>,
-    #[serde(default)]
-    pub disabled_hooks: Vec<String>,
-    #[serde(default)]
-    pub disabled_skills: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub lsp: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub experimental: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub background_task: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub browser_automation_engine: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub claude_code: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub other_fields: Option<serde_json::Value>,
-    pub updated_at: String,
-}
-
-impl Default for OmoGlobalConfig {
-    fn default() -> Self {
-        Self {
-            id: "global".to_string(),
-            schema_url: None,
-            sisyphus_agent: None,
-            disabled_agents: vec![],
-            disabled_mcps: vec![],
-            disabled_hooks: vec![],
-            disabled_skills: vec![],
-            lsp: None,
-            experimental: None,
-            background_task: None,
-            browser_automation_engine: None,
-            claude_code: None,
-            other_fields: None,
-            updated_at: chrono::Utc::now().to_rfc3339(),
-        }
-    }
-}
-
-impl Database {
-    pub fn get_omo_global_config(&self) -> Result<OmoGlobalConfig, AppError> {
-        let json_str = self.get_setting("common_config_omo")?;
-        match json_str {
-            Some(s) => serde_json::from_str::<OmoGlobalConfig>(&s)
-                .map_err(|e| AppError::Config(format!("Failed to parse common_config_omo: {e}"))),
-            None => Ok(OmoGlobalConfig::default()),
-        }
-    }
-
-    pub fn save_omo_global_config(&self, config: &OmoGlobalConfig) -> Result<(), AppError> {
-        let json_str = serde_json::to_string(config)
-            .map_err(|e| AppError::Config(format!("JSON serialization failed: {e}")))?;
-        self.set_setting("common_config_omo", &json_str)?;
-        Ok(())
-    }
-}

src-tauri/src/database/dao/providers.rs

@@ -364,25 +364,39 @@ impl Database {
         &self,
         app_type: &str,
         provider_id: &str,
+        category: &str,
     ) -> Result<(), AppError> {
         let mut conn = lock_conn!(self.conn);
         let tx = conn
             .transaction()
             .map_err(|e| AppError::Database(e.to_string()))?;
         tx.execute(
-            "UPDATE providers SET is_current = 0 WHERE app_type = ?1 AND category = 'omo'",
-            params![app_type],
+            "UPDATE providers SET is_current = 0 WHERE app_type = ?1 AND category = ?2",
+            params![app_type, category],
         )
         .map_err(|e| AppError::Database(e.to_string()))?;
+        // OMO ↔ OMO Slim mutually exclusive: deactivate the opposite category
+        let opposite = match category {
+            "omo" => Some("omo-slim"),
+            "omo-slim" => Some("omo"),
+            _ => None,
+        };
+        if let Some(opp) = opposite {
+            tx.execute(
+                "UPDATE providers SET is_current = 0 WHERE app_type = ?1 AND category = ?2",
+                params![app_type, opp],
+            )
+            .map_err(|e| AppError::Database(e.to_string()))?;
+        }
         let updated = tx
             .execute(
-            "UPDATE providers SET is_current = 1 WHERE id = ?1 AND app_type = ?2 AND category = 'omo'",
-            params![provider_id, app_type],
-        )
+                "UPDATE providers SET is_current = 1 WHERE id = ?1 AND app_type = ?2 AND category = ?3",
+                params![provider_id, app_type, category],
+            )
             .map_err(|e| AppError::Database(e.to_string()))?;
         if updated != 1 {
             return Err(AppError::Database(format!(
-                "Failed to set OMO provider current: provider '{provider_id}' not found in app '{app_type}'"
+                "Failed to set {category} provider current: provider '{provider_id}' not found in app '{app_type}'"
             )));
         }
         tx.commit().map_err(|e| AppError::Database(e.to_string()))?;
@@ -393,12 +407,13 @@ impl Database {
         &self,
         app_type: &str,
         provider_id: &str,
+        category: &str,
     ) -> Result<bool, AppError> {
         let conn = lock_conn!(self.conn);
         match conn.query_row(
             "SELECT is_current FROM providers
-             WHERE id = ?1 AND app_type = ?2 AND category = 'omo'",
-            params![provider_id, app_type],
+             WHERE id = ?1 AND app_type = ?2 AND category = ?3",
+            params![provider_id, app_type, category],
             |row| row.get(0),
         ) {
             Ok(is_current) => Ok(is_current),
@@ -411,25 +426,30 @@ impl Database {
         &self,
         app_type: &str,
         provider_id: &str,
+        category: &str,
     ) -> Result<(), AppError> {
         let conn = lock_conn!(self.conn);
         conn.execute(
             "UPDATE providers SET is_current = 0
-             WHERE id = ?1 AND app_type = ?2 AND category = 'omo'",
-            params![provider_id, app_type],
+             WHERE id = ?1 AND app_type = ?2 AND category = ?3",
+            params![provider_id, app_type, category],
         )
         .map_err(|e| AppError::Database(e.to_string()))?;
         Ok(())
     }
 
-    pub fn get_current_omo_provider(&self, app_type: &str) -> Result<Option<Provider>, AppError> {
+    pub fn get_current_omo_provider(
+        &self,
+        app_type: &str,
+        category: &str,
+    ) -> Result<Option<Provider>, AppError> {
         let conn = lock_conn!(self.conn);
         let row_data: Result<OmoProviderRow, rusqlite::Error> = conn.query_row(
             "SELECT id, name, settings_config, category, created_at, sort_index, notes, meta
              FROM providers
-             WHERE app_type = ?1 AND category = 'omo' AND is_current = 1
+             WHERE app_type = ?1 AND category = ?2 AND is_current = 1
              LIMIT 1",
-            params![app_type],
+            params![app_type, category],
             |row| {
                 Ok((
                     row.get(0)?,
@@ -444,7 +464,7 @@ impl Database {
             },
         );
 
-        let (id, name, settings_config_str, category, created_at, sort_index, notes, meta_str) =
+        let (id, name, settings_config_str, _row_category, created_at, sort_index, notes, meta_str) =
             match row_data {
                 Ok(v) => v,
                 Err(rusqlite::Error::QueryReturnedNoRows) => return Ok(None),
@@ -453,7 +473,7 @@ impl Database {
 
         let settings_config = serde_json::from_str(&settings_config_str).map_err(|e| {
             AppError::Database(format!(
-                "Failed to parse OMO provider settings_config (provider_id={id}): {e}"
+                "Failed to parse {category} provider settings_config (provider_id={id}): {e}"
             ))
         })?;
         let meta: crate::provider::ProviderMeta = if meta_str.trim().is_empty() {
@@ -461,7 +481,7 @@ impl Database {
         } else {
             serde_json::from_str(&meta_str).map_err(|e| {
                 AppError::Database(format!(
-                    "Failed to parse OMO provider meta (provider_id={id}): {e}"
+                    "Failed to parse {category} provider meta (provider_id={id}): {e}"
                 ))
             })?
         };
@@ -471,7 +491,7 @@ impl Database {
             name,
             settings_config,
             website_url: None,
-            category,
+            category: Some(category.to_string()),
             created_at,
             sort_index,
             notes,

src-tauri/src/database/dao/settings.rs

@@ -38,7 +38,7 @@ impl Database {
         Ok(())
     }
 
-    // --- Config Snippets 辅助方法 ---
+    // --- 通用配置片段 (Common Config Snippet) ---
 
     /// 获取通用配置片段
     pub fn get_config_snippet(&self, app_type: &str) -> Result<Option<String>, AppError> {

src-tauri/src/database/mod.rs

@@ -23,7 +23,7 @@
 //!     └── settings.rs
 //! ```
 
-mod backup;
+pub(crate) mod backup;
 mod dao;
 mod migration;
 mod schema;
@@ -33,19 +33,15 @@ mod tests;
 
 // DAO 类型导出供外部使用
 pub use dao::FailoverQueueItem;
-pub use dao::OmoGlobalConfig;
 
 use crate::config::get_app_config_dir;
 use crate::error::AppError;
-use rusqlite::Connection;
+use rusqlite::{hooks::Action, Connection};
 use serde::Serialize;
 use std::sync::Mutex;
 
 // DAO 方法通过 impl Database 提供，无需额外导出
 
-/// 数据库备份保留数量
-const DB_BACKUP_RETAIN: usize = 10;
-
 /// 当前 Schema 版本号
 /// 每次修改表结构时递增，并在 schema.rs 中添加相应的迁移逻辑
 pub(crate) const SCHEMA_VERSION: i32 = 5;
@@ -76,6 +72,17 @@ pub struct Database {
     pub(crate) conn: Mutex<Connection>,
 }
 
+fn register_db_change_hook(conn: &Connection) {
+    conn.update_hook(Some(
+        |action: Action, _database: &str, table: &str, _row_id: i64| match action {
+            Action::SQLITE_INSERT | Action::SQLITE_UPDATE | Action::SQLITE_DELETE => {
+                crate::services::webdav_auto_sync::notify_db_changed(table);
+            }
+            _ => {}
+        },
+    ));
+}
+
 impl Database {
     /// 初始化数据库连接并创建表
     ///
@@ -93,11 +100,28 @@ impl Database {
         // 启用外键约束
         conn.execute("PRAGMA foreign_keys = ON;", [])
             .map_err(|e| AppError::Database(e.to_string()))?;
+        register_db_change_hook(&conn);
 
         let db = Self {
             conn: Mutex::new(conn),
         };
         db.create_tables()?;
+
+        // Pre-migration backup: only when upgrading from an existing database
+        {
+            let conn = lock_conn!(db.conn);
+            let version = Self::get_user_version(&conn)?;
+            drop(conn);
+            if version > 0 && version < SCHEMA_VERSION {
+                log::info!(
+                    "Creating pre-migration database backup (v{version} → v{SCHEMA_VERSION})"
+                );
+                if let Err(e) = db.backup_database_file() {
+                    log::warn!("Pre-migration backup failed, continuing migration: {e}");
+                }
+            }
+        }
+
         db.apply_schema_migrations()?;
         db.ensure_model_pricing_seeded()?;
 
@@ -111,6 +135,7 @@ impl Database {
         // 启用外键约束
         conn.execute("PRAGMA foreign_keys = ON;", [])
             .map_err(|e| AppError::Database(e.to_string()))?;
+        register_db_change_hook(&conn);
 
         let db = Self {
             conn: Mutex::new(conn),

src-tauri/src/database/tests.rs

@@ -297,6 +297,15 @@ fn schema_migration_v4_adds_pricing_model_columns() {
         r#"
         CREATE TABLE proxy_config (app_type TEXT PRIMARY KEY);
         CREATE TABLE proxy_request_logs (request_id TEXT PRIMARY KEY, model TEXT NOT NULL);
+        CREATE TABLE mcp_servers (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            server_config TEXT NOT NULL,
+            enabled_claude INTEGER NOT NULL DEFAULT 0,
+            enabled_codex INTEGER NOT NULL DEFAULT 0,
+            enabled_gemini INTEGER NOT NULL DEFAULT 0,
+            enabled_opencode INTEGER NOT NULL DEFAULT 0
+        );
         "#,
     )
     .expect("seed v4 schema");

src-tauri/src/deeplink/mcp.rs

@@ -175,6 +175,10 @@ pub(crate) fn parse_mcp_apps(apps_str: &str) -> Result<McpApps, AppError> {
             "codex" => apps.codex = true,
             "gemini" => apps.gemini = true,
             "opencode" => apps.opencode = true,
+            "openclaw" => {
+                // OpenClaw doesn't support MCP, ignore silently
+                log::debug!("OpenClaw doesn't support MCP, ignoring in apps parameter");
+            }
             other => {
                 return Err(AppError::InvalidInput(format!(
                     "Invalid app in 'apps': {other}"

src-tauri/src/deeplink/provider.rs

@@ -146,6 +146,7 @@ pub(crate) fn build_provider_from_request(
         AppType::Codex => build_codex_settings(request),
         AppType::Gemini => build_gemini_settings(request),
         AppType::OpenCode => build_opencode_settings(request),
+        AppType::OpenClaw => build_openclaw_settings(request),
     };
 
     // Build usage script configuration if provided
@@ -391,6 +392,35 @@ fn build_opencode_settings(request: &DeepLinkImportRequest) -> serde_json::Value
     })
 }
 
+fn build_openclaw_settings(request: &DeepLinkImportRequest) -> serde_json::Value {
+    let endpoint = get_primary_endpoint(request);
+
+    // Build OpenClaw provider config
+    // Format: { baseUrl, apiKey, api, models }
+    let mut config = serde_json::Map::new();
+
+    if !endpoint.is_empty() {
+        config.insert("baseUrl".to_string(), json!(endpoint));
+    }
+
+    if let Some(api_key) = &request.api_key {
+        config.insert("apiKey".to_string(), json!(api_key));
+    }
+
+    // Default to OpenAI-compatible API
+    config.insert("api".to_string(), json!("openai-completions"));
+
+    // Build models array
+    if let Some(model) = &request.model {
+        config.insert(
+            "models".to_string(),
+            json!([{ "id": model, "name": model }]),
+        );
+    }
+
+    json!(config)
+}
+
 // =============================================================================
 // Config Merge Logic
 // =============================================================================
@@ -452,6 +482,10 @@ pub fn parse_and_merge_config(
         "claude" => merge_claude_config(&mut merged, &config_value)?,
         "codex" => merge_codex_config(&mut merged, &config_value)?,
         "gemini" => merge_gemini_config(&mut merged, &config_value)?,
+        // Additive mode apps use JSON config directly; pass through as-is
+        "openclaw" | "opencode" => {
+            merge_additive_config(&mut merged, &config_value)?;
+        }
         "" => {
             // No app specified, skip merging
             return Ok(merged);
@@ -623,6 +657,47 @@ fn merge_gemini_config(
     Ok(())
 }
 
+/// Merge configuration for additive mode apps (OpenClaw, OpenCode)
+///
+/// These apps use JSON config directly, so we only extract common fields
+/// (api_key, endpoint, model) from the config if not already set in URL params.
+fn merge_additive_config(
+    request: &mut DeepLinkImportRequest,
+    config: &serde_json::Value,
+) -> Result<(), AppError> {
+    // Extract api_key from config if not provided in URL
+    if request.api_key.as_ref().is_none_or(|s| s.is_empty()) {
+        if let Some(api_key) = config
+            .get("apiKey")
+            .or_else(|| config.get("api_key"))
+            .and_then(|v| v.as_str())
+        {
+            request.api_key = Some(api_key.to_string());
+        }
+    }
+
+    // Extract endpoint from config if not provided in URL
+    if request.endpoint.as_ref().is_none_or(|s| s.is_empty()) {
+        if let Some(base_url) = config
+            .get("baseUrl")
+            .or_else(|| config.get("base_url"))
+            .or_else(|| config.get("options").and_then(|o| o.get("baseURL")))
+            .and_then(|v| v.as_str())
+        {
+            request.endpoint = Some(base_url.to_string());
+        }
+    }
+
+    // Auto-fill homepage from endpoint
+    if request.homepage.as_ref().is_none_or(|s| s.is_empty()) {
+        if let Some(endpoint) = request.endpoint.as_ref().filter(|s| !s.is_empty()) {
+            request.homepage = infer_homepage_from_endpoint(endpoint);
+        }
+    }
+
+    Ok(())
+}
+
 /// Extract base_url from Codex TOML config
 fn extract_codex_base_url(toml_value: &toml::Value) -> Option<String> {
     // Try to find base_url in model_providers section

src-tauri/src/lib.rs

@@ -13,6 +13,7 @@ mod gemini_config;
 mod gemini_mcp;
 mod init_status;
 mod mcp;
+mod openclaw_config;
 mod opencode_config;
 mod panic_hook;
 mod prompt;
@@ -447,63 +448,7 @@ pub fn run() {
                 Err(e) => log::warn!("✗ Failed to read skills migration flag: {e}"),
             }
 
-            // 2. 导入供应商配置（已有内置检查：该应用已有供应商则跳过）
-            for app in [
-                crate::app_config::AppType::Claude,
-                crate::app_config::AppType::Codex,
-                crate::app_config::AppType::Gemini,
-            ] {
-                match crate::services::provider::ProviderService::import_default_config(
-                    &app_state,
-                    app.clone(),
-                ) {
-                    Ok(true) => {
-                        log::info!("✓ Imported default provider for {}", app.as_str());
-
-                        // 首次运行：自动提取通用配置片段（仅当通用配置为空时）
-                        if app_state
-                            .db
-                            .get_config_snippet(app.as_str())
-                            .ok()
-                            .flatten()
-                            .is_none()
-                        {
-                            match crate::services::provider::ProviderService::extract_common_config_snippet(&app_state, app.clone()) {
-                                Ok(snippet) if !snippet.is_empty() && snippet != "{}" => {
-                                    if let Err(e) = app_state.db.set_config_snippet(app.as_str(), Some(snippet)) {
-                                        log::warn!("✗ Failed to save common config snippet for {}: {e}", app.as_str());
-                                    } else {
-                                        log::info!("✓ Extracted common config snippet for {}", app.as_str());
-                                    }
-                                }
-                                Ok(_) => log::debug!("○ No common config to extract for {}", app.as_str()),
-                                Err(e) => log::debug!("○ Failed to extract common config for {}: {e}", app.as_str()),
-                            }
-                        }
-                    }
-                    Ok(false) => {} // 已有供应商，静默跳过
-                    Err(e) => {
-                        log::debug!(
-                            "○ No default provider to import for {}: {}",
-                            app.as_str(),
-                            e
-                        );
-                    }
-                }
-            }
-
-            // 2.1 OpenCode 供应商导入（累加式模式，需特殊处理）
-            // OpenCode 与其他应用不同：配置文件中可同时存在多个供应商
-            // 需要遍历 provider 字段下的每个供应商并导入
-            match crate::services::provider::import_opencode_providers_from_live(&app_state) {
-                Ok(count) if count > 0 => {
-                    log::info!("✓ Imported {count} OpenCode provider(s) from live config");
-                }
-                Ok(_) => log::debug!("○ No OpenCode providers found to import"),
-                Err(e) => log::debug!("○ Failed to import OpenCode providers: {e}"),
-            }
-
-            // 2.2 OMO 配置导入（当数据库中无 OMO provider 时，从本地文件导入）
+            // 2. OMO 配置导入（当数据库中无 OMO provider 时，从本地文件导入）
             {
                 let has_omo = app_state
                     .db
@@ -511,7 +456,7 @@ pub fn run() {
                     .map(|providers| providers.values().any(|p| p.category.as_deref() == Some("omo")))
                     .unwrap_or(false);
                 if !has_omo {
-                    match crate::services::OmoService::import_from_local(&app_state) {
+                    match crate::services::OmoService::import_from_local(&app_state, &crate::services::omo::STANDARD) {
                         Ok(provider) => {
                             log::info!("✓ Imported OMO config from local as provider '{}'", provider.name);
                         }
@@ -525,6 +470,35 @@ pub fn run() {
                 }
             }
 
+            // 2.3 OMO Slim config import (when no omo-slim provider in DB, import from local)
+            {
+                let has_omo_slim = app_state
+                    .db
+                    .get_all_providers("opencode")
+                    .map(|providers| {
+                        providers
+                            .values()
+                            .any(|p| p.category.as_deref() == Some("omo-slim"))
+                    })
+                    .unwrap_or(false);
+                if !has_omo_slim {
+                    match crate::services::OmoService::import_from_local(&app_state, &crate::services::omo::SLIM) {
+                        Ok(provider) => {
+                            log::info!(
+                                "✓ Imported OMO Slim config from local as provider '{}'",
+                                provider.name
+                            );
+                        }
+                        Err(AppError::OmoConfigNotFound) => {
+                            log::debug!("○ No OMO Slim config to import");
+                        }
+                        Err(e) => {
+                            log::warn!("✗ Failed to import OMO Slim config from local: {e}");
+                        }
+                    }
+                }
+            }
+
             // 3. 导入 MCP 服务器配置（表空时触发）
             if app_state.db.is_mcp_table_empty().unwrap_or(false) {
                 log::info!("MCP table empty, importing from live configurations...");
@@ -570,6 +544,8 @@ pub fn run() {
                     crate::app_config::AppType::Claude,
                     crate::app_config::AppType::Codex,
                     crate::app_config::AppType::Gemini,
+                    crate::app_config::AppType::OpenCode,
+                    crate::app_config::AppType::OpenClaw,
                 ] {
                     match crate::services::prompt::PromptService::import_from_file_on_first_launch(
                         &app_state,
@@ -688,6 +664,10 @@ pub fn run() {
             }
 
             let _tray = tray_builder.build(app)?;
+            crate::services::webdav_auto_sync::start_worker(
+                app_state.db.clone(),
+                app.handle().clone(),
+            );
             // 将同一个实例注入到全局状态，避免重复创建导致的不一致
             app.manage(app_state);
 
@@ -766,6 +746,25 @@ pub fn run() {
 
                 // 检查 settings 表中的代理状态，自动恢复代理服务
                 restore_proxy_state_on_startup(&state).await;
+
+                // Periodic backup check (on startup)
+                if let Err(e) = state.db.periodic_backup_if_needed() {
+                    log::warn!("Periodic backup failed on startup: {e}");
+                }
+
+                // Periodic backup timer: check every hour while the app is running
+                let db_for_timer = state.db.clone();
+                tauri::async_runtime::spawn(async move {
+                    let mut interval =
+                        tokio::time::interval(std::time::Duration::from_secs(3600));
+                    interval.tick().await; // skip immediate first tick (already checked above)
+                    loop {
+                        interval.tick().await;
+                        if let Err(e) = db_for_timer.periodic_backup_if_needed() {
+                            log::warn!("Periodic backup timer failed: {e}");
+                        }
+                    }
+                });
             });
 
             // Linux: 禁用 WebKitGTK 硬件加速，防止 EGL 初始化失败导致白屏
@@ -886,9 +885,19 @@ pub fn run() {
             // theirs: config import/export and dialogs
             commands::export_config_to_file,
             commands::import_config_from_file,
+            commands::webdav_test_connection,
+            commands::webdav_sync_upload,
+            commands::webdav_sync_download,
+            commands::webdav_sync_save_settings,
+            commands::webdav_sync_fetch_remote_info,
             commands::save_file_dialog,
             commands::open_file_dialog,
             commands::open_zip_file_dialog,
+            commands::create_db_backup,
+            commands::list_db_backups,
+            commands::restore_db_backup,
+            commands::rename_db_backup,
+            commands::delete_db_backup,
             commands::sync_current_providers_live,
             // Deep link import
             commands::parse_deeplink,
@@ -987,6 +996,19 @@ pub fn run() {
             // OpenCode specific
             commands::import_opencode_providers_from_live,
             commands::get_opencode_live_provider_ids,
+            // OpenClaw specific
+            commands::import_openclaw_providers_from_live,
+            commands::get_openclaw_live_provider_ids,
+            commands::get_openclaw_default_model,
+            commands::set_openclaw_default_model,
+            commands::get_openclaw_model_catalog,
+            commands::set_openclaw_model_catalog,
+            commands::get_openclaw_agents_defaults,
+            commands::set_openclaw_agents_defaults,
+            commands::get_openclaw_env,
+            commands::set_openclaw_env,
+            commands::get_openclaw_tools,
+            commands::set_openclaw_tools,
             // Global upstream proxy
             commands::get_global_proxy_url,
             commands::set_global_proxy_url,
@@ -997,8 +1019,20 @@ pub fn run() {
             commands::set_window_theme,
             commands::read_omo_local_file,
             commands::get_current_omo_provider_id,
-            commands::get_omo_provider_count,
             commands::disable_current_omo,
+            commands::read_omo_slim_local_file,
+            commands::get_current_omo_slim_provider_id,
+            commands::disable_current_omo_slim,
+            // Workspace files (OpenClaw)
+            commands::read_workspace_file,
+            commands::write_workspace_file,
+            // Daily memory files (OpenClaw workspace)
+            commands::list_daily_memory_files,
+            commands::read_daily_memory_file,
+            commands::write_daily_memory_file,
+            commands::delete_daily_memory_file,
+            commands::search_daily_memory_files,
+            commands::open_workspace_directory,
         ]);
 
     let app = builder

src-tauri/src/openclaw_config.rs

@@ -0,0 +1,546 @@
+//! OpenClaw 配置文件读写模块
+//!
+//! 处理 `~/.openclaw/openclaw.json` 配置文件的读写操作（JSON5 格式）。
+//! OpenClaw 使用累加式供应商管理，所有供应商配置共存于同一配置文件中。
+//!
+//! ## 配置文件格式
+//!
+//! ```json5
+//! {
+//!   // 模型供应商配置（映射为 CC Switch 的"供应商"）
+//!   models: {
+//!     mode: "merge",
+//!     providers: {
+//!       "custom-provider": {
+//!         baseUrl: "https://api.example.com/v1",
+//!         apiKey: "${API_KEY}",
+//!         api: "openai-completions",
+//!         models: [{ id: "model-id", name: "Model Name" }]
+//!       }
+//!     }
+//!   },
+//!   // 环境变量配置
+//!   env: {
+//!     ANTHROPIC_API_KEY: "sk-...",
+//!     vars: { ... }
+//!   },
+//!   // Agent 默认模型配置
+//!   agents: {
+//!     defaults: {
+//!       model: {
+//!         primary: "provider/model",
+//!         fallbacks: ["provider2/model2"]
+//!       }
+//!     }
+//!   }
+//! }
+//! ```
+
+use crate::config::write_json_file;
+use crate::error::AppError;
+use crate::settings::get_openclaw_override_dir;
+use indexmap::IndexMap;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Map, Value};
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+// ============================================================================
+// Path Functions
+// ============================================================================
+
+/// 获取 OpenClaw 配置目录
+///
+/// 默认路径: `~/.openclaw/`
+/// 可通过 settings.openclaw_config_dir 覆盖
+pub fn get_openclaw_dir() -> PathBuf {
+    if let Some(override_dir) = get_openclaw_override_dir() {
+        return override_dir;
+    }
+
+    // 所有平台统一使用 ~/.openclaw
+    dirs::home_dir()
+        .map(|h| h.join(".openclaw"))
+        .unwrap_or_else(|| PathBuf::from(".openclaw"))
+}
+
+/// 获取 OpenClaw 配置文件路径
+///
+/// 返回 `~/.openclaw/openclaw.json`
+pub fn get_openclaw_config_path() -> PathBuf {
+    get_openclaw_dir().join("openclaw.json")
+}
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+/// OpenClaw 供应商配置（对应 models.providers 中的条目）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OpenClawProviderConfig {
+    /// API 基础 URL
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub base_url: Option<String>,
+
+    /// API Key（支持环境变量引用 ${VAR_NAME}）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api_key: Option<String>,
+
+    /// API 类型（如 "openai-completions", "anthropic" 等）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+
+    /// 支持的模型列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub models: Vec<OpenClawModelEntry>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw 模型条目
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OpenClawModelEntry {
+    /// 模型 ID
+    pub id: String,
+
+    /// 模型显示名称
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+
+    /// 模型别名（用于快捷引用）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alias: Option<String>,
+
+    /// 模型成本（输入/输出价格）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cost: Option<OpenClawModelCost>,
+
+    /// 上下文窗口大小
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub context_window: Option<u32>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw 模型成本配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawModelCost {
+    /// 输入价格（每百万 token）
+    pub input: f64,
+
+    /// 输出价格（每百万 token）
+    pub output: f64,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw 默认模型配置（agents.defaults.model）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawDefaultModel {
+    /// 主模型 ID（格式：provider/model）
+    pub primary: String,
+
+    /// 回退模型列表
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub fallbacks: Vec<String>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw 模型目录条目（agents.defaults.models 中的值）
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawModelCatalogEntry {
+    /// 模型别名（用于 UI 显示）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alias: Option<String>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw agents.defaults 配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawAgentsDefaults {
+    /// 默认模型配置
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub model: Option<OpenClawDefaultModel>,
+
+    /// 模型目录/允许列表（键为 provider/model 格式）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub models: Option<HashMap<String, OpenClawModelCatalogEntry>>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// OpenClaw agents 顶层配置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(dead_code)]
+pub struct OpenClawAgents {
+    /// 默认配置
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub defaults: Option<OpenClawAgentsDefaults>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+// ============================================================================
+// Core Read/Write Functions
+// ============================================================================
+
+/// 读取 OpenClaw 配置文件
+///
+/// 支持 JSON5 格式，返回完整的配置 JSON 对象
+pub fn read_openclaw_config() -> Result<Value, AppError> {
+    let path = get_openclaw_config_path();
+
+    if !path.exists() {
+        // Return empty config structure
+        return Ok(json!({
+            "models": {
+                "mode": "merge",
+                "providers": {}
+            }
+        }));
+    }
+
+    let content = std::fs::read_to_string(&path).map_err(|e| AppError::io(&path, e))?;
+
+    // 尝试 JSON5 解析（支持注释和尾随逗号）
+    json5::from_str(&content)
+        .map_err(|e| AppError::Config(format!("Failed to parse OpenClaw config as JSON5: {}", e)))
+}
+
+/// 写入 OpenClaw 配置文件（原子写入）
+///
+/// 使用标准 JSON 格式写入（JSON5 是 JSON 的超集）
+pub fn write_openclaw_config(config: &Value) -> Result<(), AppError> {
+    let path = get_openclaw_config_path();
+
+    // 确保目录存在
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
+    }
+
+    // 复用统一的原子写入逻辑
+    write_json_file(&path, config)?;
+
+    log::debug!("OpenClaw config written to {path:?}");
+    Ok(())
+}
+
+// ============================================================================
+// Provider Functions (Untyped - for raw JSON operations)
+// ============================================================================
+
+/// 获取所有供应商配置（原始 JSON）
+///
+/// 从 `models.providers` 读取
+pub fn get_providers() -> Result<Map<String, Value>, AppError> {
+    let config = read_openclaw_config()?;
+    Ok(config
+        .get("models")
+        .and_then(|m| m.get("providers"))
+        .and_then(|v| v.as_object())
+        .cloned()
+        .unwrap_or_default())
+}
+
+/// 设置供应商配置（原始 JSON）
+///
+/// 写入到 `models.providers`
+pub fn set_provider(id: &str, provider_config: Value) -> Result<(), AppError> {
+    let mut full_config = read_openclaw_config()?;
+
+    // 确保 models 结构存在
+    if full_config.get("models").is_none() {
+        full_config["models"] = json!({
+            "mode": "merge",
+            "providers": {}
+        });
+    }
+
+    // 确保 providers 对象存在
+    if full_config["models"].get("providers").is_none() {
+        full_config["models"]["providers"] = json!({});
+    }
+
+    // 设置供应商
+    if let Some(providers) = full_config["models"]
+        .get_mut("providers")
+        .and_then(|v| v.as_object_mut())
+    {
+        providers.insert(id.to_string(), provider_config);
+    }
+
+    write_openclaw_config(&full_config)
+}
+
+/// 删除供应商配置
+pub fn remove_provider(id: &str) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    if let Some(providers) = config
+        .get_mut("models")
+        .and_then(|m| m.get_mut("providers"))
+        .and_then(|v| v.as_object_mut())
+    {
+        providers.remove(id);
+    }
+
+    write_openclaw_config(&config)
+}
+
+// ============================================================================
+// Provider Functions (Typed)
+// ============================================================================
+
+/// 获取所有供应商配置（类型化）
+pub fn get_typed_providers() -> Result<IndexMap<String, OpenClawProviderConfig>, AppError> {
+    let providers = get_providers()?;
+    let mut result = IndexMap::new();
+
+    for (id, value) in providers {
+        match serde_json::from_value::<OpenClawProviderConfig>(value.clone()) {
+            Ok(config) => {
+                result.insert(id, config);
+            }
+            Err(e) => {
+                log::warn!("Failed to parse OpenClaw provider '{id}': {e}");
+                // Skip invalid providers but continue
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+/// 设置供应商配置（类型化）
+pub fn set_typed_provider(id: &str, config: &OpenClawProviderConfig) -> Result<(), AppError> {
+    let value = serde_json::to_value(config).map_err(|e| AppError::JsonSerialize { source: e })?;
+    set_provider(id, value)
+}
+
+// ============================================================================
+// Agents Configuration Functions
+// ============================================================================
+
+/// 读取默认模型配置（agents.defaults.model）
+pub fn get_default_model() -> Result<Option<OpenClawDefaultModel>, AppError> {
+    let config = read_openclaw_config()?;
+
+    let Some(model_value) = config
+        .get("agents")
+        .and_then(|a| a.get("defaults"))
+        .and_then(|d| d.get("model"))
+    else {
+        return Ok(None);
+    };
+
+    let model = serde_json::from_value(model_value.clone())
+        .map_err(|e| AppError::Config(format!("Failed to parse agents.defaults.model: {e}")))?;
+
+    Ok(Some(model))
+}
+
+/// 设置默认模型配置（agents.defaults.model）
+pub fn set_default_model(model: &OpenClawDefaultModel) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    // Ensure agents.defaults path exists, preserving unknown fields
+    ensure_agents_defaults_path(&mut config);
+
+    let model_value =
+        serde_json::to_value(model).map_err(|e| AppError::JsonSerialize { source: e })?;
+
+    config["agents"]["defaults"]["model"] = model_value;
+
+    write_openclaw_config(&config)
+}
+
+/// 读取模型目录/允许列表（agents.defaults.models）
+pub fn get_model_catalog() -> Result<Option<HashMap<String, OpenClawModelCatalogEntry>>, AppError> {
+    let config = read_openclaw_config()?;
+
+    let Some(models_value) = config
+        .get("agents")
+        .and_then(|a| a.get("defaults"))
+        .and_then(|d| d.get("models"))
+    else {
+        return Ok(None);
+    };
+
+    let catalog = serde_json::from_value(models_value.clone())
+        .map_err(|e| AppError::Config(format!("Failed to parse agents.defaults.models: {e}")))?;
+
+    Ok(Some(catalog))
+}
+
+/// 设置模型目录/允许列表（agents.defaults.models）
+pub fn set_model_catalog(
+    catalog: &HashMap<String, OpenClawModelCatalogEntry>,
+) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    // Ensure agents.defaults path exists, preserving unknown fields
+    ensure_agents_defaults_path(&mut config);
+
+    let catalog_value =
+        serde_json::to_value(catalog).map_err(|e| AppError::JsonSerialize { source: e })?;
+
+    config["agents"]["defaults"]["models"] = catalog_value;
+
+    write_openclaw_config(&config)
+}
+
+/// Ensure the `agents.defaults` path exists in the config,
+/// preserving any existing unknown fields.
+fn ensure_agents_defaults_path(config: &mut Value) {
+    if config.get("agents").is_none() {
+        config["agents"] = json!({});
+    }
+    if config["agents"].get("defaults").is_none() {
+        config["agents"]["defaults"] = json!({});
+    }
+}
+
+// ============================================================================
+// Full Agents Defaults Functions
+// ============================================================================
+
+/// Read the full agents.defaults config
+pub fn get_agents_defaults() -> Result<Option<OpenClawAgentsDefaults>, AppError> {
+    let config = read_openclaw_config()?;
+
+    let Some(defaults_value) = config.get("agents").and_then(|a| a.get("defaults")) else {
+        return Ok(None);
+    };
+
+    let defaults = serde_json::from_value(defaults_value.clone())
+        .map_err(|e| AppError::Config(format!("Failed to parse agents.defaults: {e}")))?;
+
+    Ok(Some(defaults))
+}
+
+/// Write the full agents.defaults config
+pub fn set_agents_defaults(defaults: &OpenClawAgentsDefaults) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    if config.get("agents").is_none() {
+        config["agents"] = json!({});
+    }
+
+    let value =
+        serde_json::to_value(defaults).map_err(|e| AppError::JsonSerialize { source: e })?;
+
+    config["agents"]["defaults"] = value;
+
+    write_openclaw_config(&config)
+}
+
+// ============================================================================
+// Env Configuration
+// ============================================================================
+
+/// OpenClaw env configuration (env section of openclaw.json)
+///
+/// Stores environment variables like API keys and custom vars.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawEnvConfig {
+    /// All environment variable key-value pairs
+    #[serde(flatten)]
+    pub vars: HashMap<String, Value>,
+}
+
+/// Read the env config section
+pub fn get_env_config() -> Result<OpenClawEnvConfig, AppError> {
+    let config = read_openclaw_config()?;
+
+    let Some(env_value) = config.get("env") else {
+        return Ok(OpenClawEnvConfig {
+            vars: HashMap::new(),
+        });
+    };
+
+    serde_json::from_value(env_value.clone())
+        .map_err(|e| AppError::Config(format!("Failed to parse env config: {e}")))
+}
+
+/// Write the env config section
+pub fn set_env_config(env: &OpenClawEnvConfig) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    let value = serde_json::to_value(env).map_err(|e| AppError::JsonSerialize { source: e })?;
+
+    config["env"] = value;
+
+    write_openclaw_config(&config)
+}
+
+// ============================================================================
+// Tools Configuration
+// ============================================================================
+
+/// OpenClaw tools configuration (tools section of openclaw.json)
+///
+/// Controls tool permissions with profile-based allow/deny lists.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OpenClawToolsConfig {
+    /// Active permission profile (e.g. "default", "strict", "permissive")
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub profile: Option<String>,
+
+    /// Allowed tool patterns
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub allow: Vec<String>,
+
+    /// Denied tool patterns
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub deny: Vec<String>,
+
+    /// Other custom fields (preserve unknown fields)
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// Read the tools config section
+pub fn get_tools_config() -> Result<OpenClawToolsConfig, AppError> {
+    let config = read_openclaw_config()?;
+
+    let Some(tools_value) = config.get("tools") else {
+        return Ok(OpenClawToolsConfig {
+            profile: None,
+            allow: Vec::new(),
+            deny: Vec::new(),
+            extra: HashMap::new(),
+        });
+    };
+
+    serde_json::from_value(tools_value.clone())
+        .map_err(|e| AppError::Config(format!("Failed to parse tools config: {e}")))
+}
+
+/// Write the tools config section
+pub fn set_tools_config(tools: &OpenClawToolsConfig) -> Result<(), AppError> {
+    let mut config = read_openclaw_config()?;
+
+    let value = serde_json::to_value(tools).map_err(|e| AppError::JsonSerialize { source: e })?;
+
+    config["tools"] = value;
+
+    write_openclaw_config(&config)
+}

src-tauri/src/opencode_config.rs

@@ -145,14 +145,25 @@ pub fn add_plugin(plugin_name: &str) -> Result<(), AppError> {
 
     match plugins {
         Some(arr) => {
+            // Mutual exclusion: standard OMO and OMO Slim cannot coexist as plugins
             if plugin_name.starts_with("oh-my-opencode")
                 && !plugin_name.starts_with("oh-my-opencode-slim")
             {
+                // Adding standard OMO -> remove all Slim variants
                 arr.retain(|v| {
                     v.as_str()
                         .map(|s| !s.starts_with("oh-my-opencode-slim"))
                         .unwrap_or(true)
                 });
+            } else if plugin_name.starts_with("oh-my-opencode-slim") {
+                // Adding Slim -> remove all standard OMO variants (but keep slim)
+                arr.retain(|v| {
+                    v.as_str()
+                        .map(|s| {
+                            !s.starts_with("oh-my-opencode") || s.starts_with("oh-my-opencode-slim")
+                        })
+                        .unwrap_or(true)
+                });
             }
 
             let already_exists = arr.iter().any(|v| v.as_str() == Some(plugin_name));

src-tauri/src/prompt_files.rs

@@ -5,6 +5,7 @@ use crate::codex_config::get_codex_auth_path;
 use crate::config::get_claude_settings_path;
 use crate::error::AppError;
 use crate::gemini_config::get_gemini_dir;
+use crate::openclaw_config::get_openclaw_dir;
 use crate::opencode_config::get_opencode_dir;
 
 /// 返回指定应用所使用的提示词文件路径。
@@ -14,6 +15,7 @@ pub fn prompt_file_path(app: &AppType) -> Result<PathBuf, AppError> {
         AppType::Codex => get_base_dir_with_fallback(get_codex_auth_path(), ".codex")?,
         AppType::Gemini => get_gemini_dir(),
         AppType::OpenCode => get_opencode_dir(),
+        AppType::OpenClaw => get_openclaw_dir(),
     };
 
     let filename = match app {
@@ -21,6 +23,7 @@ pub fn prompt_file_path(app: &AppType) -> Result<PathBuf, AppError> {
         AppType::Codex => "AGENTS.md",
         AppType::Gemini => "GEMINI.md",
         AppType::OpenCode => "AGENTS.md",
+        AppType::OpenClaw => "AGENTS.md", // OpenClaw uses AGENTS.md for agent instructions
     };
 
     Ok(base_dir.join(filename))

src-tauri/src/proxy/providers/claude.rs

@@ -263,10 +263,13 @@ impl ProviderAdapter for ClaudeAdapter {
             base = base.replace("/v1/v1", "/v1");
         }
 
-        // 为 Claude 相关端点添加 ?beta=true 参数
+        // 为 Claude 原生 /v1/messages 端点添加 ?beta=true 参数
         // 这是某些上游服务（如 DuckCoding）验证请求来源的关键参数
-        // 注：openai_chat 模式下会转发到 /v1/chat/completions，此处也需要保持一致
-        if (endpoint.contains("/v1/messages") || endpoint.contains("/v1/chat/completions"))
+        // 注意：不要为 OpenAI Chat Completions (/v1/chat/completions) 添加此参数
+        //       当 apiFormat="openai_chat" 时，请求会转发到 /v1/chat/completions，
+        //       但该端点是 OpenAI 标准，不支持 ?beta=true 参数
+        if endpoint.contains("/v1/messages")
+            && !endpoint.contains("/v1/chat/completions")
             && !endpoint.contains('?')
         {
             format!("{base}?beta=true")
@@ -513,6 +516,15 @@ mod tests {
         assert_eq!(url, "https://api.anthropic.com/v1/messages?foo=bar");
     }
 
+    #[test]
+    fn test_build_url_no_beta_for_openai_chat_completions() {
+        let adapter = ClaudeAdapter::new();
+        // OpenAI Chat Completions 端点不添加 ?beta=true
+        // 这是 Nvidia 等 apiFormat="openai_chat" 供应商使用的端点
+        let url = adapter.build_url("https://integrate.api.nvidia.com", "/v1/chat/completions");
+        assert_eq!(url, "https://integrate.api.nvidia.com/v1/chat/completions");
+    }
+
     #[test]
     fn test_needs_transform() {
         let adapter = ClaudeAdapter::new();

src-tauri/src/proxy/providers/mod.rs

@@ -136,6 +136,10 @@ impl ProviderType {
                 // OpenCode doesn't support proxy, but return a default type for completeness
                 ProviderType::Codex // Fallback to Codex-like type
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy, but return a default type for completeness
+                ProviderType::Codex // Fallback to Codex-like type
+            }
         }
     }
 
@@ -184,6 +188,10 @@ pub fn get_adapter(app_type: &AppType) -> Box<dyn ProviderAdapter> {
             // OpenCode doesn't support proxy, fallback to Codex adapter
             Box::new(CodexAdapter::new())
         }
+        AppType::OpenClaw => {
+            // OpenClaw doesn't support proxy, fallback to Codex adapter
+            Box::new(CodexAdapter::new())
+        }
     }
 }
 

src-tauri/src/proxy/types.rs

@@ -113,6 +113,8 @@ pub struct ProxyTakeoverStatus {
     pub claude: bool,
     pub codex: bool,
     pub gemini: bool,
+    pub opencode: bool,
+    pub openclaw: bool,
 }
 
 /// API 格式类型（预留，当前不需要格式转换）

src-tauri/src/services/config.rs

@@ -126,6 +126,10 @@ impl ConfigService {
                 // OpenCode uses additive mode, no live sync needed
                 // OpenCode providers are managed directly in the config file
             }
+            AppType::OpenClaw => {
+                // OpenClaw uses additive mode, no live sync needed
+                // OpenClaw providers are managed directly in the config file
+            }
         }
 
         Ok(())

src-tauri/src/services/mcp.rs

@@ -123,6 +123,11 @@ impl McpService {
                     &server.server,
                 )?;
             }
+            AppType::OpenClaw => {
+                // OpenClaw MCP support is still in development (Issue #4834)
+                // Skip for now
+                log::debug!("OpenClaw MCP support is still in development, skipping sync");
+            }
         }
         Ok(())
     }
@@ -148,6 +153,10 @@ impl McpService {
             AppType::OpenCode => {
                 mcp::remove_server_from_opencode(id)?;
             }
+            AppType::OpenClaw => {
+                // OpenClaw MCP support is still in development
+                log::debug!("OpenClaw MCP support is still in development, skipping remove");
+            }
         }
         Ok(())
     }

src-tauri/src/services/mod.rs

@@ -10,12 +10,15 @@ pub mod skill;
 pub mod speedtest;
 pub mod stream_check;
 pub mod usage_stats;
+pub mod webdav;
+pub mod webdav_auto_sync;
+pub mod webdav_sync;
 
 pub use config::ConfigService;
 pub use mcp::McpService;
 pub use omo::OmoService;
 pub use prompt::PromptService;
-pub use provider::{ProviderService, ProviderSortUpdate};
+pub use provider::{ProviderService, ProviderSortUpdate, SwitchResult};
 pub use proxy::ProxyService;
 #[allow(unused_imports)]
 pub use skill::{DiscoverableSkill, Skill, SkillRepo, SkillService};

src-tauri/src/services/omo.rs

@@ -1,5 +1,4 @@
 use crate::config::write_json_file;
-use crate::database::OmoGlobalConfig;
 use crate::error::AppError;
 use crate::opencode_config::get_opencode_dir;
 use crate::store::AppState;
@@ -13,22 +12,60 @@ pub struct OmoLocalFileData {
     pub agents: Option<Value>,
     pub categories: Option<Value>,
     pub other_fields: Option<Value>,
-    pub global: OmoGlobalConfig,
     pub file_path: String,
     pub last_modified: Option<String>,
 }
 
-type OmoProfileData = (Option<Value>, Option<Value>, Option<Value>, bool);
+type OmoProfileData = (Option<Value>, Option<Value>, Option<Value>);
+
+// ── Variant descriptor ─────────────────────────────────────────
+
+pub struct OmoVariant {
+    pub filename: &'static str,
+    pub category: &'static str,
+    pub provider_prefix: &'static str,
+    pub plugin_name: &'static str,
+    pub plugin_prefix: &'static str,
+    pub has_categories: bool,
+    pub label: &'static str,
+    pub import_label: &'static str,
+}
+
+pub const STANDARD: OmoVariant = OmoVariant {
+    filename: "oh-my-opencode.jsonc",
+    category: "omo",
+    provider_prefix: "omo-",
+    plugin_name: "oh-my-opencode@latest",
+    plugin_prefix: "oh-my-opencode",
+    has_categories: true,
+    label: "OMO",
+    import_label: "Imported",
+};
+
+pub const SLIM: OmoVariant = OmoVariant {
+    filename: "oh-my-opencode-slim.jsonc",
+    category: "omo-slim",
+    provider_prefix: "omo-slim-",
+    plugin_name: "oh-my-opencode-slim@latest",
+    plugin_prefix: "oh-my-opencode-slim",
+    has_categories: false,
+    label: "OMO Slim",
+    import_label: "Imported Slim",
+};
+
+// ── Service ────────────────────────────────────────────────────
 
 pub struct OmoService;
 
 impl OmoService {
-    fn config_path() -> PathBuf {
-        get_opencode_dir().join("oh-my-opencode.jsonc")
+    // ── Path helpers ────────────────────────────────────────
+
+    fn config_path(v: &OmoVariant) -> PathBuf {
+        get_opencode_dir().join(v.filename)
     }
 
-    fn resolve_local_config_path() -> Result<PathBuf, AppError> {
-        let config_path = Self::config_path();
+    fn resolve_local_config_path(v: &OmoVariant) -> Result<PathBuf, AppError> {
+        let config_path = Self::config_path(v);
         if config_path.exists() {
             return Ok(config_path);
         }
@@ -52,72 +89,22 @@ impl OmoService {
             .ok_or_else(|| AppError::Config("Expected JSON object".to_string()))
     }
 
-    fn extract_other_fields(obj: &Map<String, Value>) -> Map<String, Value> {
-        const KNOWN_KEYS: [&str; 13] = [
-            "$schema",
-            "agents",
-            "categories",
-            "sisyphus_agent",
-            "disabled_agents",
-            "disabled_mcps",
-            "disabled_hooks",
-            "disabled_skills",
-            "lsp",
-            "experimental",
-            "background_task",
-            "browser_automation_engine",
-            "claude_code",
-        ];
+    // ── Field extraction ───────────────────────────────────
 
+    fn extract_other_fields_with_keys(
+        obj: &Map<String, Value>,
+        known: &[&str],
+    ) -> Map<String, Value> {
         let mut other = Map::new();
         for (k, v) in obj {
-            if !KNOWN_KEYS.contains(&k.as_str()) {
+            if !known.contains(&k.as_str()) {
                 other.insert(k.clone(), v.clone());
             }
         }
         other
     }
 
-    fn extract_string_array(val: &Value) -> Vec<String> {
-        val.as_array()
-            .map(|arr| {
-                arr.iter()
-                    .filter_map(|v| v.as_str().map(String::from))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn merge_global_from_obj(obj: &Map<String, Value>, global: &mut OmoGlobalConfig) {
-        if let Some(v) = obj.get("$schema") {
-            global.schema_url = v.as_str().map(|s| s.to_string());
-        }
-        for (key, target) in [
-            ("disabled_agents", &mut global.disabled_agents),
-            ("disabled_mcps", &mut global.disabled_mcps),
-            ("disabled_hooks", &mut global.disabled_hooks),
-            ("disabled_skills", &mut global.disabled_skills),
-        ] {
-            if let Some(v) = obj.get(key) {
-                *target = Self::extract_string_array(v);
-            }
-        }
-        for (key, target) in [
-            ("sisyphus_agent", &mut global.sisyphus_agent),
-            ("lsp", &mut global.lsp),
-            ("experimental", &mut global.experimental),
-            ("background_task", &mut global.background_task),
-            (
-                "browser_automation_engine",
-                &mut global.browser_automation_engine,
-            ),
-            ("claude_code", &mut global.claude_code),
-        ] {
-            if let Some(v) = obj.get(key) {
-                *target = Some(v.clone());
-            }
-        }
-    }
+    // ── Merge helpers ──────────────────────────────────────
 
     fn insert_opt_value(result: &mut Map<String, Value>, key: &str, value: &Option<Value>) {
         if let Some(v) = value {
@@ -125,15 +112,6 @@ impl OmoService {
         }
     }
 
-    fn insert_string_array(result: &mut Map<String, Value>, key: &str, values: &[String]) {
-        if !values.is_empty() {
-            result.insert(
-                key.to_string(),
-                serde_json::to_value(values).unwrap_or(Value::Array(vec![])),
-            );
-        }
-    }
-
     fn insert_object_entries(result: &mut Map<String, Value>, value: Option<&Value>) {
         if let Some(Value::Object(map)) = value {
             for (k, v) in map {
@@ -142,115 +120,84 @@ impl OmoService {
         }
     }
 
-    pub fn delete_config_file() -> Result<(), AppError> {
-        let config_path = Self::config_path();
+    // ── Public API (variant-parameterized) ─────────────────
+
+    pub fn delete_config_file(v: &OmoVariant) -> Result<(), AppError> {
+        let config_path = Self::config_path(v);
         if config_path.exists() {
             std::fs::remove_file(&config_path).map_err(|e| AppError::io(&config_path, e))?;
-            log::info!("OMO config file deleted: {config_path:?}");
+            log::info!("{} config file deleted: {config_path:?}", v.label);
         }
-        crate::opencode_config::remove_plugin_by_prefix("oh-my-opencode")?;
+        crate::opencode_config::remove_plugin_by_prefix(v.plugin_prefix)?;
         Ok(())
     }
 
-    pub fn write_config_to_file(state: &AppState) -> Result<(), AppError> {
-        let global = state.db.get_omo_global_config()?;
-        let current_omo = state.db.get_current_omo_provider("opencode")?;
-
+    pub fn write_config_to_file(state: &AppState, v: &OmoVariant) -> Result<(), AppError> {
+        let current_omo = state.db.get_current_omo_provider("opencode", v.category)?;
         let profile_data = current_omo.as_ref().map(|p| {
             let agents = p.settings_config.get("agents").cloned();
-            let categories = p.settings_config.get("categories").cloned();
+            let categories = if v.has_categories {
+                p.settings_config.get("categories").cloned()
+            } else {
+                None
+            };
             let other_fields = p.settings_config.get("otherFields").cloned();
-            let use_common_config = p
-                .settings_config
-                .get("useCommonConfig")
-                .and_then(|v| v.as_bool())
-                .unwrap_or(true);
-            (agents, categories, other_fields, use_common_config)
+            (agents, categories, other_fields)
         });
 
-        let merged = Self::merge_config(&global, profile_data.as_ref());
-        let config_path = Self::config_path();
+        let merged = Self::build_config(v, profile_data.as_ref());
+        let config_path = Self::config_path(v);
 
         if let Some(parent) = config_path.parent() {
             std::fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
         }
 
         write_json_file(&config_path, &merged)?;
-
-        crate::opencode_config::add_plugin("oh-my-opencode@latest")?;
-
-        log::info!("OMO config written to {config_path:?}");
+        crate::opencode_config::add_plugin(v.plugin_name)?;
+        log::info!("{} config written to {config_path:?}", v.label);
         Ok(())
     }
 
-    fn merge_config(global: &OmoGlobalConfig, profile_data: Option<&OmoProfileData>) -> Value {
+    fn build_config(v: &OmoVariant, profile_data: Option<&OmoProfileData>) -> Value {
         let mut result = Map::new();
-        let use_common_config = profile_data.map(|(_, _, _, v)| *v).unwrap_or(true);
-
-        if use_common_config {
-            if let Some(url) = &global.schema_url {
-                result.insert("$schema".to_string(), Value::String(url.clone()));
-            }
-
-            Self::insert_opt_value(&mut result, "sisyphus_agent", &global.sisyphus_agent);
-            Self::insert_string_array(&mut result, "disabled_agents", &global.disabled_agents);
-            Self::insert_string_array(&mut result, "disabled_mcps", &global.disabled_mcps);
-            Self::insert_string_array(&mut result, "disabled_hooks", &global.disabled_hooks);
-            Self::insert_string_array(&mut result, "disabled_skills", &global.disabled_skills);
-            Self::insert_opt_value(&mut result, "lsp", &global.lsp);
-            Self::insert_opt_value(&mut result, "experimental", &global.experimental);
-            Self::insert_opt_value(&mut result, "background_task", &global.background_task);
-            Self::insert_opt_value(
-                &mut result,
-                "browser_automation_engine",
-                &global.browser_automation_engine,
-            );
-            Self::insert_opt_value(&mut result, "claude_code", &global.claude_code);
-
-            Self::insert_object_entries(&mut result, global.other_fields.as_ref());
-        }
-
-        if let Some((agents, categories, other_fields, _)) = profile_data {
-            Self::insert_opt_value(&mut result, "agents", agents);
-            Self::insert_opt_value(&mut result, "categories", categories);
+        if let Some((agents, categories, other_fields)) = profile_data {
             Self::insert_object_entries(&mut result, other_fields.as_ref());
+            Self::insert_opt_value(&mut result, "agents", agents);
+            if v.has_categories {
+                Self::insert_opt_value(&mut result, "categories", categories);
+            }
         }
-
         Value::Object(result)
     }
 
-    pub fn import_from_local(state: &AppState) -> Result<crate::provider::Provider, AppError> {
-        let actual_path = Self::resolve_local_config_path()?;
-        Self::import_from_path(state, &actual_path)
-    }
-
-    fn import_from_path(
+    pub fn import_from_local(
         state: &AppState,
-        path: &std::path::Path,
+        v: &OmoVariant,
     ) -> Result<crate::provider::Provider, AppError> {
-        let obj = Self::read_jsonc_object(path)?;
+        let actual_path = Self::resolve_local_config_path(v)?;
+        let obj = Self::read_jsonc_object(&actual_path)?;
 
         let mut settings = Map::new();
         if let Some(agents) = obj.get("agents") {
             settings.insert("agents".to_string(), agents.clone());
         }
-        if let Some(categories) = obj.get("categories") {
-            settings.insert("categories".to_string(), categories.clone());
+        if v.has_categories {
+            if let Some(categories) = obj.get("categories") {
+                settings.insert("categories".to_string(), categories.clone());
+            }
         }
-        settings.insert("useCommonConfig".to_string(), Value::Bool(true));
 
-        let other = Self::extract_other_fields(&obj);
+        let other = Self::extract_other_fields_with_keys(&obj, &["agents", "categories"]);
         if !other.is_empty() {
             settings.insert("otherFields".to_string(), Value::Object(other));
         }
 
-        let mut global = state.db.get_omo_global_config()?;
-        Self::merge_global_from_obj(&obj, &mut global);
-        global.updated_at = chrono::Utc::now().to_rfc3339();
-        state.db.save_omo_global_config(&global)?;
-
-        let provider_id = format!("omo-{}", uuid::Uuid::new_v4());
-        let name = format!("Imported {}", chrono::Local::now().format("%Y-%m-%d %H:%M"));
+        let provider_id = format!("{}{}", v.provider_prefix, uuid::Uuid::new_v4());
+        let name = format!(
+            "{} {}",
+            v.import_label,
+            chrono::Local::now().format("%Y-%m-%d %H:%M")
+        );
         let settings_config =
             serde_json::to_value(&settings).unwrap_or_else(|_| serde_json::json!({}));
 
@@ -259,7 +206,7 @@ impl OmoService {
             name,
             settings_config,
             website_url: None,
-            category: Some("omo".to_string()),
+            category: Some(v.category.to_string()),
             created_at: Some(chrono::Utc::now().timestamp_millis()),
             sort_index: None,
             notes: None,
@@ -272,13 +219,13 @@ impl OmoService {
         state.db.save_provider("opencode", &provider)?;
         state
             .db
-            .set_omo_provider_current("opencode", &provider.id)?;
-        Self::write_config_to_file(state)?;
+            .set_omo_provider_current("opencode", &provider.id, v.category)?;
+        Self::write_config_to_file(state, v)?;
         Ok(provider)
     }
 
-    pub fn read_local_file() -> Result<OmoLocalFileData, AppError> {
-        let actual_path = Self::resolve_local_config_path()?;
+    pub fn read_local_file(v: &OmoVariant) -> Result<OmoLocalFileData, AppError> {
+        let actual_path = Self::resolve_local_config_path(v)?;
         let metadata = std::fs::metadata(&actual_path).ok();
         let last_modified = metadata
             .and_then(|m| m.modified().ok())
@@ -286,37 +233,38 @@ impl OmoService {
 
         let obj = Self::read_jsonc_object(&actual_path)?;
 
-        Ok(Self::build_local_file_data_from_obj(
+        Ok(Self::build_local_file_data(
+            v,
             &obj,
             actual_path.to_string_lossy().to_string(),
             last_modified,
         ))
     }
 
-    fn build_local_file_data_from_obj(
+    fn build_local_file_data(
+        v: &OmoVariant,
         obj: &Map<String, Value>,
         file_path: String,
         last_modified: Option<String>,
     ) -> OmoLocalFileData {
         let agents = obj.get("agents").cloned();
-        let categories = obj.get("categories").cloned();
+        let categories = if v.has_categories {
+            obj.get("categories").cloned()
+        } else {
+            None
+        };
 
-        let other = Self::extract_other_fields(obj);
+        let other = Self::extract_other_fields_with_keys(obj, &["agents", "categories"]);
         let other_fields = if other.is_empty() {
             None
         } else {
             Some(Value::Object(other))
         };
 
-        let mut global = OmoGlobalConfig::default();
-        Self::merge_global_from_obj(obj, &mut global);
-        global.other_fields = other_fields.clone();
-
         OmoLocalFileData {
             agents,
             categories,
             other_fields,
-            global,
             file_path,
             last_modified,
         }
@@ -399,26 +347,24 @@ mod tests {
     }
 
     #[test]
-    fn test_merge_config_empty() {
-        let global = OmoGlobalConfig::default();
-        let merged = OmoService::merge_config(&global, None);
+    fn test_build_config_empty() {
+        let merged = OmoService::build_config(&STANDARD, None);
         assert!(merged.is_object());
+        assert!(merged.as_object().unwrap().is_empty());
     }
 
     #[test]
-    fn test_merge_config_with_profile() {
-        let global = OmoGlobalConfig {
-            schema_url: Some("https://example.com/schema.json".to_string()),
-            disabled_agents: vec!["explore".to_string()],
-            ..Default::default()
-        };
+    fn test_build_config_with_profile() {
         let agents = Some(serde_json::json!({
             "sisyphus": { "model": "claude-opus-4-5" }
         }));
         let categories = None;
-        let other_fields = None;
-        let profile_data = (agents, categories, other_fields, true);
-        let merged = OmoService::merge_config(&global, Some(&profile_data));
+        let other_fields = Some(serde_json::json!({
+            "$schema": "https://example.com/schema.json",
+            "disabled_agents": ["explore"]
+        }));
+        let profile_data = (agents, categories, other_fields);
+        let merged = OmoService::build_config(&STANDARD, Some(&profile_data));
         let obj = merged.as_object().unwrap();
 
         assert_eq!(obj["$schema"], "https://example.com/schema.json");
@@ -428,28 +374,7 @@ mod tests {
     }
 
     #[test]
-    fn test_merge_config_without_common_config() {
-        let global = OmoGlobalConfig {
-            schema_url: Some("https://example.com/schema.json".to_string()),
-            disabled_agents: vec!["explore".to_string()],
-            ..Default::default()
-        };
-        let agents = Some(serde_json::json!({
-            "sisyphus": { "model": "claude-opus-4-5" }
-        }));
-        let categories = None;
-        let other_fields = None;
-        let profile_data = (agents, categories, other_fields, false);
-        let merged = OmoService::merge_config(&global, Some(&profile_data));
-        let obj = merged.as_object().unwrap();
-
-        assert!(!obj.contains_key("$schema"));
-        assert!(!obj.contains_key("disabled_agents"));
-        assert!(obj.contains_key("agents"));
-    }
-
-    #[test]
-    fn test_build_local_file_data_keeps_unknown_top_level_fields_in_global() {
+    fn test_build_local_file_data_keeps_all_non_agent_category_fields_in_other() {
         let obj = serde_json::json!({
             "$schema": "https://example.com/schema.json",
             "disabled_agents": ["oracle"],
@@ -465,43 +390,65 @@ mod tests {
         });
         let obj_map = obj.as_object().unwrap().clone();
 
-        let data = OmoService::build_local_file_data_from_obj(
+        let data = OmoService::build_local_file_data(
+            &STANDARD,
             &obj_map,
             "/tmp/oh-my-opencode.jsonc".to_string(),
             None,
         );
 
+        // All non-agents/categories fields should be in other_fields
+        let other = data.other_fields.unwrap();
+        let other_obj = other.as_object().unwrap();
         assert_eq!(
-            data.global.schema_url.as_deref(),
-            Some("https://example.com/schema.json")
+            other_obj.get("$schema").unwrap(),
+            "https://example.com/schema.json"
         );
-        assert_eq!(data.global.disabled_agents, vec!["oracle".to_string()]);
-
         assert_eq!(
-            data.other_fields,
-            Some(serde_json::json!({
-                "custom_top_level": { "enabled": true }
-            }))
+            other_obj.get("disabled_agents").unwrap(),
+            &serde_json::json!(["oracle"])
         );
-        assert_eq!(data.global.other_fields, data.other_fields);
+        assert_eq!(
+            other_obj.get("custom_top_level").unwrap(),
+            &serde_json::json!({"enabled": true})
+        );
+        // agents and categories should NOT be in other_fields
+        assert!(!other_obj.contains_key("agents"));
+        assert!(!other_obj.contains_key("categories"));
     }
 
     #[test]
-    fn test_merge_config_ignores_non_object_other_fields() {
-        let global = OmoGlobalConfig {
-            other_fields: Some(serde_json::json!(["global_non_object"])),
-            ..Default::default()
-        };
+    fn test_build_config_ignores_non_object_other_fields() {
         let agents = None;
         let categories = None;
         let other_fields = Some(serde_json::json!("profile_non_object"));
-        let profile_data = (agents, categories, other_fields, true);
+        let profile_data = (agents, categories, other_fields);
 
-        let merged = OmoService::merge_config(&global, Some(&profile_data));
+        let merged = OmoService::build_config(&STANDARD, Some(&profile_data));
         let obj = merged.as_object().unwrap();
 
-        assert!(!obj.contains_key("0"));
-        assert!(!obj.contains_key("global_non_object"));
         assert!(!obj.contains_key("profile_non_object"));
     }
+
+    #[test]
+    fn test_build_config_slim_excludes_categories() {
+        let agents = Some(serde_json::json!({"orchestrator": {"model": "k2"}}));
+        let categories = Some(serde_json::json!({"code": {"model": "gpt"}}));
+        let other_fields = Some(serde_json::json!({
+            "$schema": "https://slim.schema",
+            "disabled_agents": ["oracle"]
+        }));
+        let profile_data = (agents, categories, other_fields);
+
+        let merged = OmoService::build_config(&SLIM, Some(&profile_data));
+        let obj = merged.as_object().unwrap();
+
+        // Slim should NOT include categories
+        assert!(!obj.contains_key("categories"));
+
+        // Slim SHOULD include these
+        assert_eq!(obj["$schema"], "https://slim.schema");
+        assert!(obj.contains_key("agents"));
+        assert!(obj.contains_key("disabled_agents"));
+    }
 }

src-tauri/src/services/provider/live.rs

@@ -191,6 +191,48 @@ pub(crate) fn write_live_snapshot(app_type: &AppType, provider: &Provider) -> Re
                 }
             }
         }
+        AppType::OpenClaw => {
+            // OpenClaw uses additive mode - write provider to config
+            use crate::openclaw_config;
+            use crate::openclaw_config::OpenClawProviderConfig;
+
+            // Convert settings_config to OpenClawProviderConfig
+            let openclaw_config_result =
+                serde_json::from_value::<OpenClawProviderConfig>(provider.settings_config.clone());
+
+            match openclaw_config_result {
+                Ok(config) => {
+                    openclaw_config::set_typed_provider(&provider.id, &config)?;
+                    log::info!("OpenClaw provider '{}' written to live config", provider.id);
+                }
+                Err(e) => {
+                    log::warn!(
+                        "Failed to parse OpenClaw provider config for '{}': {}",
+                        provider.id,
+                        e
+                    );
+                    // Try to write as raw JSON if it looks valid
+                    if provider.settings_config.get("baseUrl").is_some()
+                        || provider.settings_config.get("api").is_some()
+                        || provider.settings_config.get("models").is_some()
+                    {
+                        openclaw_config::set_provider(
+                            &provider.id,
+                            provider.settings_config.clone(),
+                        )?;
+                        log::info!(
+                            "OpenClaw provider '{}' written as raw JSON to live config",
+                            provider.id
+                        );
+                    } else {
+                        log::error!(
+                            "OpenClaw provider '{}' has invalid config structure, skipping write",
+                            provider.id
+                        );
+                    }
+                }
+            }
+        }
     }
     Ok(())
 }
@@ -340,6 +382,21 @@ pub fn read_live_settings(app_type: AppType) -> Result<Value, AppError> {
             let config = read_opencode_config()?;
             Ok(config)
         }
+        AppType::OpenClaw => {
+            use crate::openclaw_config::{get_openclaw_config_path, read_openclaw_config};
+
+            let config_path = get_openclaw_config_path();
+            if !config_path.exists() {
+                return Err(AppError::localized(
+                    "openclaw.config.missing",
+                    "OpenClaw 配置文件不存在",
+                    "OpenClaw configuration file not found",
+                ));
+            }
+
+            let config = read_openclaw_config()?;
+            Ok(config)
+        }
     }
 }
 
@@ -348,6 +405,12 @@ pub fn read_live_settings(app_type: AppType) -> Result<Value, AppError> {
 /// Returns `Ok(true)` if a provider was actually imported,
 /// `Ok(false)` if skipped (providers already exist for this app).
 pub fn import_default_config(state: &AppState, app_type: AppType) -> Result<bool, AppError> {
+    // Additive mode apps (OpenCode, OpenClaw) should use their dedicated
+    // import_xxx_providers_from_live functions, not this generic default config import
+    if app_type.is_additive_mode() {
+        return Ok(false);
+    }
+
     {
         let providers = state.db.get_all_providers(app_type.as_str())?;
         if !providers.is_empty() {
@@ -415,23 +478,9 @@ pub fn import_default_config(state: &AppState, app_type: AppType) -> Result<bool
                 "config": config_obj
             })
         }
-        AppType::OpenCode => {
-            // OpenCode uses additive mode - import from live is not the same pattern
-            // For now, return an empty config structure
-            use crate::opencode_config::{get_opencode_config_path, read_opencode_config};
-
-            let config_path = get_opencode_config_path();
-            if !config_path.exists() {
-                return Err(AppError::localized(
-                    "opencode.live.missing",
-                    "OpenCode 配置文件不存在",
-                    "OpenCode configuration file is missing",
-                ));
-            }
-
-            // For OpenCode, we return the full config - but note that OpenCode
-            // uses additive mode, so importing defaults works differently
-            read_opencode_config()?
+        // OpenCode and OpenClaw use additive mode and are handled by early return above
+        AppType::OpenCode | AppType::OpenClaw => {
+            unreachable!("additive mode apps are handled by early return")
         }
     };
 
@@ -609,3 +658,87 @@ pub fn import_opencode_providers_from_live(state: &AppState) -> Result<usize, Ap
 
     Ok(imported)
 }
+
+/// Import all providers from OpenClaw live config to database
+///
+/// This imports existing providers from ~/.openclaw/openclaw.json
+/// into the CC Switch database. Each provider found will be added to the
+/// database with is_current set to false.
+pub fn import_openclaw_providers_from_live(state: &AppState) -> Result<usize, AppError> {
+    use crate::openclaw_config;
+
+    let providers = openclaw_config::get_typed_providers()?;
+    if providers.is_empty() {
+        return Ok(0);
+    }
+
+    let mut imported = 0;
+    let existing = state.db.get_all_providers("openclaw")?;
+
+    for (id, config) in providers {
+        // Validate: skip entries with empty id or no models
+        if id.trim().is_empty() {
+            log::warn!("Skipping OpenClaw provider with empty id");
+            continue;
+        }
+        if config.models.is_empty() {
+            log::warn!("Skipping OpenClaw provider '{id}': no models defined");
+            continue;
+        }
+
+        // Skip if already exists in database
+        if existing.contains_key(&id) {
+            log::debug!("OpenClaw provider '{id}' already exists in database, skipping");
+            continue;
+        }
+
+        // Convert to Value for settings_config
+        let settings_config = match serde_json::to_value(&config) {
+            Ok(v) => v,
+            Err(e) => {
+                log::warn!("Failed to serialize OpenClaw provider '{id}': {e}");
+                continue;
+            }
+        };
+
+        // Determine display name: use first model name if available, otherwise use id
+        let display_name = config
+            .models
+            .first()
+            .and_then(|m| m.name.clone())
+            .unwrap_or_else(|| id.clone());
+
+        // Create provider
+        let provider = Provider::with_id(id.clone(), display_name, settings_config, None);
+
+        // Save to database
+        if let Err(e) = state.db.save_provider("openclaw", &provider) {
+            log::warn!("Failed to import OpenClaw provider '{id}': {e}");
+            continue;
+        }
+
+        imported += 1;
+        log::info!("Imported OpenClaw provider '{id}' from live config");
+    }
+
+    Ok(imported)
+}
+
+/// Remove an OpenClaw provider from live config
+///
+/// This removes a specific provider from ~/.openclaw/openclaw.json
+/// without affecting other providers in the file.
+pub fn remove_openclaw_provider_from_live(provider_id: &str) -> Result<(), AppError> {
+    use crate::openclaw_config;
+
+    // Check if OpenClaw config directory exists
+    if !openclaw_config::get_openclaw_dir().exists() {
+        log::debug!("OpenClaw config directory doesn't exist, skipping removal of '{provider_id}'");
+        return Ok(());
+    }
+
+    openclaw_config::remove_provider(provider_id)?;
+    log::info!("OpenClaw provider '{provider_id}' removed from live config");
+
+    Ok(())
+}

src-tauri/src/services/provider/mod.rs

@@ -21,8 +21,8 @@ use crate::store::AppState;
 
 // Re-export sub-module functions for external access
 pub use live::{
-    import_default_config, import_opencode_providers_from_live, read_live_settings,
-    sync_current_to_live,
+    import_default_config, import_openclaw_providers_from_live,
+    import_opencode_providers_from_live, read_live_settings, sync_current_to_live,
 };
 
 // Internal re-exports (pub(crate))
@@ -30,12 +30,21 @@ pub(crate) use live::sanitize_claude_settings_for_live;
 pub(crate) use live::write_live_snapshot;
 
 // Internal re-exports
-use live::{remove_opencode_provider_from_live, write_gemini_live};
+use live::{
+    remove_openclaw_provider_from_live, remove_opencode_provider_from_live, write_gemini_live,
+};
 use usage::validate_usage_script;
 
 /// Provider business logic service
 pub struct ProviderService;
 
+/// Result of a provider switch operation, including any non-fatal warnings
+#[derive(Debug, serde::Serialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct SwitchResult {
+    pub warnings: Vec<String>,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -142,10 +151,10 @@ impl ProviderService {
     /// 优先从本地 settings 读取，验证后 fallback 到数据库的 is_current 字段。
     /// 这确保了云同步场景下多设备可以独立选择供应商，且返回的 ID 一定有效。
     ///
-    /// 对于 OpenCode（累加模式），不存在"当前供应商"概念，直接返回空字符串。
+    /// 对于累加模式应用（OpenCode, OpenClaw），不存在"当前供应商"概念，直接返回空字符串。
     pub fn current(state: &AppState, app_type: AppType) -> Result<String, AppError> {
-        // OpenCode uses additive mode - no "current" provider concept
-        if matches!(app_type, AppType::OpenCode) {
+        // Additive mode apps have no "current" provider concept
+        if app_type.is_additive_mode() {
             return Ok(String::new());
         }
         crate::settings::get_effective_current_provider(&state.db, &app_type)
@@ -162,11 +171,13 @@ impl ProviderService {
         // Save to database
         state.db.save_provider(app_type.as_str(), &provider)?;
 
-        // OpenCode uses additive mode - always write to live config
-        if matches!(app_type, AppType::OpenCode) {
-            // OMO providers use exclusive mode and write to dedicated config file.
-            if provider.category.as_deref() == Some("omo") {
-                // Do not auto-enable newly added OMO providers.
+        // Additive mode apps (OpenCode, OpenClaw) - always write to live config
+        if app_type.is_additive_mode() {
+            // OMO / OMO Slim providers use exclusive mode and write to dedicated config file.
+            if matches!(app_type, AppType::OpenCode)
+                && matches!(provider.category.as_deref(), Some("omo") | Some("omo-slim"))
+            {
+                // Do not auto-enable newly added OMO / OMO Slim providers.
                 // Users must explicitly switch/apply an OMO provider to activate it.
                 return Ok(true);
             }
@@ -201,14 +212,35 @@ impl ProviderService {
         // Save to database
         state.db.save_provider(app_type.as_str(), &provider)?;
 
-        // OpenCode uses additive mode - always update in live config
-        if matches!(app_type, AppType::OpenCode) {
-            if provider.category.as_deref() == Some("omo") {
-                let is_omo_current = state
-                    .db
-                    .is_omo_provider_current(app_type.as_str(), &provider.id)?;
+        // Additive mode apps (OpenCode, OpenClaw) - always update in live config
+        if app_type.is_additive_mode() {
+            if matches!(app_type, AppType::OpenCode) && provider.category.as_deref() == Some("omo")
+            {
+                let is_omo_current =
+                    state
+                        .db
+                        .is_omo_provider_current(app_type.as_str(), &provider.id, "omo")?;
                 if is_omo_current {
-                    crate::services::OmoService::write_config_to_file(state)?;
+                    crate::services::OmoService::write_config_to_file(
+                        state,
+                        &crate::services::omo::STANDARD,
+                    )?;
+                }
+                return Ok(true);
+            }
+            if matches!(app_type, AppType::OpenCode)
+                && provider.category.as_deref() == Some("omo-slim")
+            {
+                let is_current = state.db.is_omo_provider_current(
+                    app_type.as_str(),
+                    &provider.id,
+                    "omo-slim",
+                )?;
+                if is_current {
+                    crate::services::OmoService::write_config_to_file(
+                        state,
+                        &crate::services::omo::SLIM,
+                    )?;
                 }
                 return Ok(true);
             }
@@ -253,43 +285,54 @@ impl ProviderService {
     /// Delete a provider
     ///
     /// 同时检查本地 settings 和数据库的当前供应商，防止删除任一端正在使用的供应商。
-    /// 对于 OpenCode（累加模式），可以随时删除任意供应商，同时从 live 配置中移除。
+    /// 对于累加模式应用（OpenCode, OpenClaw），可以随时删除任意供应商，同时从 live 配置中移除。
     pub fn delete(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
-        // OpenCode uses additive mode - no current provider concept
-        if matches!(app_type, AppType::OpenCode) {
-            let is_omo = state
-                .db
-                .get_provider_by_id(id, app_type.as_str())?
-                .and_then(|p| p.category)
-                .as_deref()
-                == Some("omo");
-
-            if is_omo {
-                let was_current = state.db.is_omo_provider_current(app_type.as_str(), id)?;
-                let omo_count = state
+        // Additive mode apps - no current provider concept
+        if app_type.is_additive_mode() {
+            if matches!(app_type, AppType::OpenCode) {
+                let provider_category = state
                     .db
-                    .get_all_providers(app_type.as_str())?
-                    .values()
-                    .filter(|p| p.category.as_deref() == Some("omo"))
-                    .count();
+                    .get_provider_by_id(id, app_type.as_str())?
+                    .and_then(|p| p.category);
 
-                if omo_count <= 1 && was_current {
-                    return Err(AppError::Message(
-                        "无法删除当前启用的最后一个 OMO 配置，请先停用".to_string(),
-                    ));
+                if provider_category.as_deref() == Some("omo") {
+                    let was_current =
+                        state
+                            .db
+                            .is_omo_provider_current(app_type.as_str(), id, "omo")?;
+
+                    state.db.delete_provider(app_type.as_str(), id)?;
+                    if was_current {
+                        crate::services::OmoService::delete_config_file(
+                            &crate::services::omo::STANDARD,
+                        )?;
+                    }
+                    return Ok(());
                 }
 
-                state.db.delete_provider(app_type.as_str(), id)?;
-                if was_current {
-                    crate::services::OmoService::delete_config_file()?;
+                if provider_category.as_deref() == Some("omo-slim") {
+                    let was_current =
+                        state
+                            .db
+                            .is_omo_provider_current(app_type.as_str(), id, "omo-slim")?;
+
+                    state.db.delete_provider(app_type.as_str(), id)?;
+                    if was_current {
+                        crate::services::OmoService::delete_config_file(
+                            &crate::services::omo::SLIM,
+                        )?;
+                    }
+                    return Ok(());
                 }
-                return Ok(());
             }
-
             // Remove from database
             state.db.delete_provider(app_type.as_str(), id)?;
             // Also remove from live config
-            remove_opencode_provider_from_live(id)?;
+            match app_type {
+                AppType::OpenCode => remove_opencode_provider_from_live(id)?,
+                AppType::OpenClaw => remove_openclaw_provider_from_live(id)?,
+                _ => {} // Should not reach here
+            }
             return Ok(());
         }
 
@@ -306,7 +349,7 @@ impl ProviderService {
         state.db.delete_provider(app_type.as_str(), id)
     }
 
-    /// Remove provider from live config only (for additive mode apps like OpenCode)
+    /// Remove provider from live config only (for additive mode apps like OpenCode, OpenClaw)
     ///
     /// Does NOT delete from database - provider remains in the list.
     /// This is used when user wants to "remove" a provider from active config
@@ -318,27 +361,54 @@ impl ProviderService {
     ) -> Result<(), AppError> {
         match app_type {
             AppType::OpenCode => {
-                let is_omo = state
+                let provider_category = state
                     .db
                     .get_provider_by_id(id, app_type.as_str())?
-                    .and_then(|p| p.category)
-                    .as_deref()
-                    == Some("omo");
+                    .and_then(|p| p.category);
 
-                if is_omo {
-                    state.db.clear_omo_provider_current(app_type.as_str(), id)?;
-                    let still_has_current =
-                        state.db.get_current_omo_provider("opencode")?.is_some();
+                if provider_category.as_deref() == Some("omo") {
+                    state
+                        .db
+                        .clear_omo_provider_current(app_type.as_str(), id, "omo")?;
+                    let still_has_current = state
+                        .db
+                        .get_current_omo_provider("opencode", "omo")?
+                        .is_some();
                     if still_has_current {
-                        crate::services::OmoService::write_config_to_file(state)?;
+                        crate::services::OmoService::write_config_to_file(
+                            state,
+                            &crate::services::omo::STANDARD,
+                        )?;
                     } else {
-                        crate::services::OmoService::delete_config_file()?;
+                        crate::services::OmoService::delete_config_file(
+                            &crate::services::omo::STANDARD,
+                        )?;
+                    }
+                } else if provider_category.as_deref() == Some("omo-slim") {
+                    state
+                        .db
+                        .clear_omo_provider_current(app_type.as_str(), id, "omo-slim")?;
+                    let still_has_current = state
+                        .db
+                        .get_current_omo_provider("opencode", "omo-slim")?
+                        .is_some();
+                    if still_has_current {
+                        crate::services::OmoService::write_config_to_file(
+                            state,
+                            &crate::services::omo::SLIM,
+                        )?;
+                    } else {
+                        crate::services::OmoService::delete_config_file(
+                            &crate::services::omo::SLIM,
+                        )?;
                     }
                 } else {
                     remove_opencode_provider_from_live(id)?;
                 }
             }
-            // Future: add other additive mode apps here
+            AppType::OpenClaw => {
+                remove_openclaw_provider_from_live(id)?;
+            }
             _ => {
                 return Err(AppError::Message(format!(
                     "App {} does not support remove from live config",
@@ -361,7 +431,7 @@ impl ProviderService {
     ///    c. Update database is_current (as default for new devices)
     ///    d. Write target provider config to live files
     ///    e. Sync MCP configuration
-    pub fn switch(state: &AppState, app_type: AppType, id: &str) -> Result<(), AppError> {
+    pub fn switch(state: &AppState, app_type: AppType, id: &str) -> Result<SwitchResult, AppError> {
         // Check if provider exists
         let providers = state.db.get_all_providers(app_type.as_str())?;
         let _provider = providers
@@ -373,6 +443,13 @@ impl ProviderService {
             return Self::switch_normal(state, app_type, id, &providers);
         }
 
+        // OMO Slim providers are switched through their own exclusive path.
+        if matches!(app_type, AppType::OpenCode)
+            && _provider.category.as_deref() == Some("omo-slim")
+        {
+            return Self::switch_normal(state, app_type, id, &providers);
+        }
+
         // Check if proxy takeover mode is active AND proxy server is actually running
         // Both conditions must be true to use hot-switch mode
         // Use blocking wait since this is a sync function
@@ -426,7 +503,7 @@ impl ProviderService {
 
             // Note: No Live config write, no MCP sync
             // The proxy server will route requests to the new provider via is_current
-            return Ok(());
+            return Ok(SwitchResult::default());
         }
 
         // Normal mode: full switch with Live config write
@@ -439,37 +516,67 @@ impl ProviderService {
         app_type: AppType,
         id: &str,
         providers: &indexmap::IndexMap<String, Provider>,
-    ) -> Result<(), AppError> {
+    ) -> Result<SwitchResult, AppError> {
         let provider = providers
             .get(id)
             .ok_or_else(|| AppError::Message(format!("供应商 {id} 不存在")))?;
 
         if matches!(app_type, AppType::OpenCode) && provider.category.as_deref() == Some("omo") {
-            state.db.set_omo_provider_current(app_type.as_str(), id)?;
-            crate::services::OmoService::write_config_to_file(state)?;
-            return Ok(());
+            state
+                .db
+                .set_omo_provider_current(app_type.as_str(), id, "omo")?;
+            crate::services::OmoService::write_config_to_file(
+                state,
+                &crate::services::omo::STANDARD,
+            )?;
+            // OMO ↔ OMO Slim mutually exclusive: remove Slim config
+            let _ = crate::services::OmoService::delete_config_file(&crate::services::omo::SLIM);
+            return Ok(SwitchResult::default());
         }
 
+        if matches!(app_type, AppType::OpenCode) && provider.category.as_deref() == Some("omo-slim")
+        {
+            state
+                .db
+                .set_omo_provider_current(app_type.as_str(), id, "omo-slim")?;
+            crate::services::OmoService::write_config_to_file(state, &crate::services::omo::SLIM)?;
+            // OMO ↔ OMO Slim mutually exclusive: remove Standard config
+            let _ =
+                crate::services::OmoService::delete_config_file(&crate::services::omo::STANDARD);
+            return Ok(SwitchResult::default());
+        }
+
+        let mut result = SwitchResult::default();
+
         // Backfill: Backfill current live config to current provider
         // Use effective current provider (validated existence) to ensure backfill targets valid provider
         let current_id = crate::settings::get_effective_current_provider(&state.db, &app_type)?;
 
-        match (current_id, matches!(app_type, AppType::OpenCode)) {
-            (Some(current_id), false) if current_id != id => {
-                // Only backfill when switching to a different provider.
-                if let Ok(live_config) = read_live_settings(app_type.clone()) {
-                    if let Some(mut current_provider) = providers.get(&current_id).cloned() {
-                        current_provider.settings_config = live_config;
-                        // Ignore backfill failure, don't affect switch flow.
-                        let _ = state.db.save_provider(app_type.as_str(), &current_provider);
+        if let Some(current_id) = current_id {
+            if current_id != id {
+                // Additive mode apps - all providers coexist in the same file,
+                // no backfill needed (backfill is for exclusive mode apps like Claude/Codex/Gemini)
+                if !app_type.is_additive_mode() {
+                    // Only backfill when switching to a different provider
+                    if let Ok(live_config) = read_live_settings(app_type.clone()) {
+                        if let Some(mut current_provider) = providers.get(&current_id).cloned() {
+                            current_provider.settings_config = live_config;
+                            if let Err(e) =
+                                state.db.save_provider(app_type.as_str(), &current_provider)
+                            {
+                                log::warn!("Backfill failed: {e}");
+                                result
+                                    .warnings
+                                    .push(format!("backfill_failed:{current_id}"));
+                            }
+                        }
                     }
                 }
             }
-            _ => {}
         }
 
-        // OpenCode uses additive mode - skip setting is_current (no such concept)
-        if !matches!(app_type, AppType::OpenCode) {
+        // Additive mode apps skip setting is_current (no such concept)
+        if !app_type.is_additive_mode() {
             // Update local settings (device-level, takes priority)
             crate::settings::set_current_provider(&app_type, Some(id))?;
 
@@ -483,7 +590,7 @@ impl ProviderService {
         // Sync MCP
         McpService::sync_all_enabled(state)?;
 
-        Ok(())
+        Ok(result)
     }
 
     /// Sync current provider to live configuration (re-export)
@@ -515,6 +622,7 @@ impl ProviderService {
             AppType::Codex => Self::extract_codex_common_config(&provider.settings_config),
             AppType::Gemini => Self::extract_gemini_common_config(&provider.settings_config),
             AppType::OpenCode => Self::extract_opencode_common_config(&provider.settings_config),
+            AppType::OpenClaw => Self::extract_openclaw_common_config(&provider.settings_config),
         }
     }
 
@@ -528,6 +636,7 @@ impl ProviderService {
             AppType::Codex => Self::extract_codex_common_config(settings_config),
             AppType::Gemini => Self::extract_gemini_common_config(settings_config),
             AppType::OpenCode => Self::extract_opencode_common_config(settings_config),
+            AppType::OpenClaw => Self::extract_openclaw_common_config(settings_config),
         }
     }
 
@@ -684,6 +793,27 @@ impl ProviderService {
             .map_err(|e| AppError::Message(format!("Serialization failed: {e}")))
     }
 
+    /// Extract common config for OpenClaw (JSON format)
+    fn extract_openclaw_common_config(settings: &Value) -> Result<String, AppError> {
+        // OpenClaw uses a different config structure with baseUrl, apiKey, api, models
+        // For common config, we exclude provider-specific fields like apiKey
+        let mut config = settings.clone();
+
+        // Remove provider-specific fields
+        if let Some(obj) = config.as_object_mut() {
+            obj.remove("apiKey");
+            obj.remove("baseUrl");
+            // Keep api and models as they might be common
+        }
+
+        if config.is_null() || (config.is_object() && config.as_object().unwrap().is_empty()) {
+            return Ok("{}".to_string());
+        }
+
+        serde_json::to_string_pretty(&config)
+            .map_err(|e| AppError::Message(format!("Serialization failed: {e}")))
+    }
+
     /// Import default configuration from live files (re-export)
     ///
     /// Returns `Ok(true)` if imported, `Ok(false)` if skipped.
@@ -861,6 +991,17 @@ impl ProviderService {
                     ));
                 }
             }
+            AppType::OpenClaw => {
+                // OpenClaw uses config structure: { baseUrl, apiKey, api, models }
+                // Basic validation - must be an object
+                if !provider.settings_config.is_object() {
+                    return Err(AppError::localized(
+                        "provider.openclaw.settings.not_object",
+                        "OpenClaw 配置必须是 JSON 对象",
+                        "OpenClaw configuration must be a JSON object",
+                    ));
+                }
+            }
         }
 
         // Validate and clean UsageScript configuration (common for all app types)
@@ -1032,6 +1173,30 @@ impl ProviderService {
 
                 Ok((api_key, base_url))
             }
+            AppType::OpenClaw => {
+                // OpenClaw uses apiKey and baseUrl directly on the object
+                let api_key = provider
+                    .settings_config
+                    .get("apiKey")
+                    .and_then(|v| v.as_str())
+                    .ok_or_else(|| {
+                        AppError::localized(
+                            "provider.openclaw.api_key.missing",
+                            "缺少 API Key",
+                            "API key is missing",
+                        )
+                    })?
+                    .to_string();
+
+                let base_url = provider
+                    .settings_config
+                    .get("baseUrl")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("")
+                    .to_string();
+
+                Ok((api_key, base_url))
+            }
         }
     }
 }

src-tauri/src/services/proxy.rs

@@ -210,11 +210,16 @@ impl ProxyService {
             .await
             .map(|c| c.enabled)
             .unwrap_or(false);
+        // OpenCode and OpenClaw don't support proxy features, always return false
+        let opencode_enabled = false;
+        let openclaw_enabled = false;
 
         Ok(ProxyTakeoverStatus {
             claude: claude_enabled,
             codex: codex_enabled,
             gemini: gemini_enabled,
+            opencode: opencode_enabled,
+            openclaw: openclaw_enabled,
         })
     }
 
@@ -372,6 +377,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy features
                 return Err("OpenCode 不支持代理功能".to_string());
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features
+                return Err("OpenClaw 不支持代理功能".to_string());
+            }
         };
 
         self.sync_live_config_to_provider(app_type, &live_config)
@@ -588,6 +597,9 @@ impl ProxyService {
             AppType::OpenCode => {
                 // OpenCode doesn't support proxy features, skip silently
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features, skip silently
+            }
         }
 
         Ok(())
@@ -770,6 +782,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy features
                 return Err("OpenCode 不支持代理功能".to_string());
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features
+                return Err("OpenClaw 不支持代理功能".to_string());
+            }
         };
 
         let json_str = serde_json::to_string(&config)
@@ -982,6 +998,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy features
                 return Err("OpenCode 不支持代理功能".to_string());
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features
+                return Err("OpenClaw 不支持代理功能".to_string());
+            }
         }
 
         Ok(())
@@ -1068,6 +1088,9 @@ impl ProxyService {
             AppType::OpenCode => {
                 // OpenCode doesn't support proxy features, skip silently
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features, skip silently
+            }
         }
 
         Ok(())
@@ -1103,6 +1126,9 @@ impl ProxyService {
             AppType::OpenCode => {
                 // OpenCode doesn't support proxy features, skip silently
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features, skip silently
+            }
         }
 
         Ok(())
@@ -1186,6 +1212,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy features
                 Err("OpenCode 不支持代理功能".to_string())
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features
+                Err("OpenClaw 不支持代理功能".to_string())
+            }
         }
     }
 
@@ -1207,6 +1237,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy takeover
                 false
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy takeover
+                false
+            }
         }
     }
 
@@ -1250,6 +1284,10 @@ impl ProxyService {
                 // OpenCode doesn't support proxy features
                 Ok(())
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support proxy features
+                Ok(())
+            }
         }
     }
 

src-tauri/src/services/skill.rs

@@ -10,7 +10,7 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::{Component, Path, PathBuf};
 use std::sync::Arc;
 use tokio::time::timeout;
 
@@ -159,6 +159,154 @@ pub struct SkillMetadata {
     pub description: Option<String>,
 }
 
+// ========== ~/.agents/ lock 文件解析 ==========
+
+/// `~/.agents/.skill-lock.json` 文件结构
+#[derive(Deserialize)]
+struct AgentsLockFile {
+    skills: HashMap<String, AgentsLockSkill>,
+}
+
+/// lock 文件中单个 skill 的信息
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AgentsLockSkill {
+    source: Option<String>,
+    source_type: Option<String>,
+    source_url: Option<String>,
+    skill_path: Option<String>,
+    branch: Option<String>,
+    source_branch: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+struct LockRepoInfo {
+    owner: String,
+    repo: String,
+    skill_path: Option<String>,
+    branch: Option<String>,
+}
+
+fn normalize_optional_branch(branch: Option<String>) -> Option<String> {
+    branch.and_then(|b| {
+        let trimmed = b.trim();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed.to_string())
+        }
+    })
+}
+
+fn parse_branch_from_source_url(source_url: Option<&str>) -> Option<String> {
+    let source_url = source_url?;
+    let source_url = source_url.trim();
+    if source_url.is_empty() {
+        return None;
+    }
+
+    // 支持 https://github.com/owner/repo/tree/<branch>/...
+    if let Some((_, after_tree)) = source_url.split_once("/tree/") {
+        let branch = after_tree
+            .split('/')
+            .next()
+            .map(str::trim)
+            .filter(|s| !s.is_empty())?;
+        return Some(branch.to_string());
+    }
+
+    // 支持 URL fragment: ...git#branch
+    if let Some((_, fragment)) = source_url.split_once('#') {
+        let branch = fragment
+            .split('&')
+            .next()
+            .map(str::trim)
+            .filter(|s| !s.is_empty())?;
+        return Some(branch.to_string());
+    }
+
+    // 支持 query: ...?branch=xxx / ?ref=xxx
+    if let Some((_, query)) = source_url.split_once('?') {
+        for pair in query.split('&') {
+            let Some((key, value)) = pair.split_once('=') else {
+                continue;
+            };
+            if matches!(key, "branch" | "ref") {
+                let branch = value.trim();
+                if !branch.is_empty() {
+                    return Some(branch.to_string());
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// 获取 `~/.agents/skills/` 目录（存在时返回）
+fn get_agents_skills_dir() -> Option<PathBuf> {
+    dirs::home_dir()
+        .map(|h| h.join(".agents").join("skills"))
+        .filter(|p| p.exists())
+}
+
+/// 解析 `~/.agents/.skill-lock.json`，返回 skill_name -> 仓库信息
+fn parse_agents_lock() -> HashMap<String, LockRepoInfo> {
+    let path = match dirs::home_dir() {
+        Some(h) => h.join(".agents").join(".skill-lock.json"),
+        None => {
+            log::warn!("无法获取 HOME 目录，跳过解析 agents lock 文件");
+            return HashMap::new();
+        }
+    };
+    let content = match fs::read_to_string(&path) {
+        Ok(c) => c,
+        Err(e) => {
+            if e.kind() == std::io::ErrorKind::NotFound {
+                log::debug!("未找到 agents lock 文件: {}", path.display());
+            } else {
+                log::warn!("读取 agents lock 文件失败 ({}): {}", path.display(), e);
+            }
+            return HashMap::new();
+        }
+    };
+    let lock: AgentsLockFile = match serde_json::from_str(&content) {
+        Ok(l) => l,
+        Err(e) => {
+            log::warn!("解析 agents lock 文件失败 ({}): {}", path.display(), e);
+            return HashMap::new();
+        }
+    };
+    let parsed: HashMap<String, LockRepoInfo> = lock
+        .skills
+        .into_iter()
+        .filter_map(|(name, skill)| {
+            let source = skill.source?;
+            if skill.source_type.as_deref() != Some("github") {
+                return None;
+            }
+            let (owner, repo) = source.split_once('/')?;
+            let branch = normalize_optional_branch(skill.branch)
+                .or_else(|| normalize_optional_branch(skill.source_branch))
+                .or_else(|| parse_branch_from_source_url(skill.source_url.as_deref()));
+            Some((
+                name,
+                LockRepoInfo {
+                    owner: owner.to_string(),
+                    repo: repo.to_string(),
+                    skill_path: skill.skill_path,
+                    branch,
+                },
+            ))
+        })
+        .collect();
+    log::info!(
+        "agents lock 文件解析完成，共识别 {} 个 github skill",
+        parsed.len()
+    );
+    parsed
+}
+
 // ========== SkillService ==========
 
 pub struct SkillService;
@@ -230,6 +378,11 @@ impl SkillService {
                     return Ok(custom.join("skills"));
                 }
             }
+            AppType::OpenClaw => {
+                if let Some(custom) = crate::settings::get_openclaw_override_dir() {
+                    return Ok(custom.join("skills"));
+                }
+            }
         }
 
         // 默认路径：回退到用户主目录下的标准位置
@@ -244,6 +397,7 @@ impl SkillService {
             AppType::Codex => home.join(".codex").join("skills"),
             AppType::Gemini => home.join(".gemini").join("skills"),
             AppType::OpenCode => home.join(".config").join("opencode").join("skills"),
+            AppType::OpenClaw => home.join(".openclaw").join("skills"),
         })
     }
 
@@ -269,11 +423,25 @@ impl SkillService {
     ) -> Result<InstalledSkill> {
         let ssot_dir = Self::get_ssot_dir()?;
 
-        // 使用目录最后一段作为安装名
-        let install_name = Path::new(&skill.directory)
+        // 允许多级目录（如 a/b/c），但必须是安全的相对路径。
+        let source_rel = Self::sanitize_skill_source_path(&skill.directory).ok_or_else(|| {
+            anyhow!(format_skill_error(
+                "INVALID_SKILL_DIRECTORY",
+                &[("directory", &skill.directory)],
+                Some("checkZipContent"),
+            ))
+        })?;
+        // 安装目录名始终使用最后一段，避免在 SSOT 中创建多级目录。
+        let install_name = source_rel
             .file_name()
-            .map(|s| s.to_string_lossy().to_string())
-            .unwrap_or_else(|| skill.directory.clone());
+            .and_then(|name| Self::sanitize_install_name(&name.to_string_lossy()))
+            .ok_or_else(|| {
+                anyhow!(format_skill_error(
+                    "INVALID_SKILL_DIRECTORY",
+                    &[("directory", &skill.directory)],
+                    Some("checkZipContent"),
+                ))
+            })?;
 
         // 检查数据库中是否已有同名 directory 的 skill（来自其他仓库）
         let existing_skills = db.get_all_installed_skills()?;
@@ -352,7 +520,7 @@ impl SkillService {
             repo_branch = used_branch;
 
             // 复制到 SSOT
-            let source = temp_dir.join(&skill.directory);
+            let source = temp_dir.join(&source_rel);
             if !source.exists() {
                 let _ = fs::remove_dir_all(&temp_dir);
                 return Err(anyhow!(format_skill_error(
@@ -362,7 +530,24 @@ impl SkillService {
                 )));
             }
 
-            Self::copy_dir_recursive(&source, &dest)?;
+            let canonical_temp = temp_dir.canonicalize().unwrap_or_else(|_| temp_dir.clone());
+            let canonical_source = source.canonicalize().map_err(|_| {
+                anyhow!(format_skill_error(
+                    "SKILL_DIR_NOT_FOUND",
+                    &[("path", &source.display().to_string())],
+                    Some("checkRepoUrl"),
+                ))
+            })?;
+            if !canonical_source.starts_with(&canonical_temp) || !canonical_source.is_dir() {
+                let _ = fs::remove_dir_all(&temp_dir);
+                return Err(anyhow!(format_skill_error(
+                    "INVALID_SKILL_DIRECTORY",
+                    &[("directory", &skill.directory)],
+                    Some("checkZipContent"),
+                )));
+            }
+
+            Self::copy_dir_recursive(&canonical_source, &dest)?;
             let _ = fs::remove_dir_all(&temp_dir);
 
             // 使用实际下载成功的分支，避免 readme_url / repo_branch 与真实分支不一致。
@@ -443,12 +628,7 @@ impl SkillService {
             .ok_or_else(|| anyhow!("Skill not found: {id}"))?;
 
         // 从所有应用目录删除
-        for app in [
-            AppType::Claude,
-            AppType::Codex,
-            AppType::Gemini,
-            AppType::OpenCode,
-        ] {
+        for app in AppType::all() {
             let _ = Self::remove_from_app(&skill.directory, &app);
         }
 
@@ -505,73 +685,49 @@ impl SkillService {
             .map(|s| s.directory.clone())
             .collect();
 
+        // 收集所有待扫描的目录及其来源标签
+        let mut scan_sources: Vec<(PathBuf, String)> = Vec::new();
+        for app in AppType::all() {
+            if let Ok(d) = Self::get_app_skills_dir(&app) {
+                scan_sources.push((d, app.as_str().to_string()));
+            }
+        }
+        if let Some(agents_dir) = get_agents_skills_dir() {
+            scan_sources.push((agents_dir, "agents".to_string()));
+        }
+        if let Ok(ssot_dir) = Self::get_ssot_dir() {
+            scan_sources.push((ssot_dir, "cc-switch".to_string()));
+        }
+
         let mut unmanaged: HashMap<String, UnmanagedSkill> = HashMap::new();
 
-        for app in [
-            AppType::Claude,
-            AppType::Codex,
-            AppType::Gemini,
-            AppType::OpenCode,
-        ] {
-            let app_dir = match Self::get_app_skills_dir(&app) {
-                Ok(d) => d,
+        for (scan_dir, label) in &scan_sources {
+            let entries = match fs::read_dir(scan_dir) {
+                Ok(e) => e,
                 Err(_) => continue,
             };
-
-            if !app_dir.exists() {
-                continue;
-            }
-
-            for entry in fs::read_dir(&app_dir)? {
-                let entry = entry?;
+            for entry in entries.flatten() {
                 let path = entry.path();
-
                 if !path.is_dir() {
                     continue;
                 }
-
                 let dir_name = entry.file_name().to_string_lossy().to_string();
-
-                // 跳过隐藏目录（以 . 开头，如 .system）
-                if dir_name.starts_with('.') {
+                if dir_name.starts_with('.') || managed_dirs.contains(&dir_name) {
                     continue;
                 }
 
-                // 跳过已管理的
-                if managed_dirs.contains(&dir_name) {
-                    continue;
-                }
-
-                // 检查是否有 SKILL.md
                 let skill_md = path.join("SKILL.md");
-                let (name, description) = if skill_md.exists() {
-                    match Self::parse_skill_metadata_static(&skill_md) {
-                        Ok(meta) => (
-                            meta.name.unwrap_or_else(|| dir_name.clone()),
-                            meta.description,
-                        ),
-                        Err(_) => (dir_name.clone(), None),
-                    }
-                } else {
-                    (dir_name.clone(), None)
-                };
-
-                // 添加或更新
-                let app_str = match app {
-                    AppType::Claude => "claude",
-                    AppType::Codex => "codex",
-                    AppType::Gemini => "gemini",
-                    AppType::OpenCode => "opencode",
-                };
+                let (name, description) = Self::read_skill_name_desc(&skill_md, &dir_name);
 
                 unmanaged
                     .entry(dir_name.clone())
-                    .and_modify(|s| s.found_in.push(app_str.to_string()))
+                    .and_modify(|s| s.found_in.push(label.clone()))
                     .or_insert(UnmanagedSkill {
                         directory: dir_name,
                         name,
                         description,
-                        found_in: vec![app_str.to_string()],
+                        found_in: vec![label.clone()],
+                        path: path.display().to_string(),
                     });
             }
         }
@@ -587,33 +743,36 @@ impl SkillService {
         directories: Vec<String>,
     ) -> Result<Vec<InstalledSkill>> {
         let ssot_dir = Self::get_ssot_dir()?;
+        let agents_lock = parse_agents_lock();
         let mut imported = Vec::new();
 
+        // 将 lock 文件中发现的仓库保存到 skill_repos
+        save_repos_from_lock(db, &agents_lock, directories.iter().map(|s| s.as_str()));
+
+        // 收集所有候选搜索目录
+        let mut search_sources: Vec<(PathBuf, String)> = Vec::new();
+        for app in AppType::all() {
+            if let Ok(d) = Self::get_app_skills_dir(&app) {
+                search_sources.push((d, app.as_str().to_string()));
+            }
+        }
+        if let Some(agents_dir) = get_agents_skills_dir() {
+            search_sources.push((agents_dir, "agents".to_string()));
+        }
+        search_sources.push((ssot_dir.clone(), "cc-switch".to_string()));
+
         for dir_name in directories {
-            // 找到源目录（从任一应用目录复制）
+            // 在所有候选目录中查找
             let mut source_path: Option<PathBuf> = None;
             let mut found_in: Vec<String> = Vec::new();
 
-            for app in [
-                AppType::Claude,
-                AppType::Codex,
-                AppType::Gemini,
-                AppType::OpenCode,
-            ] {
-                if let Ok(app_dir) = Self::get_app_skills_dir(&app) {
-                    let skill_path = app_dir.join(&dir_name);
-                    if skill_path.exists() {
-                        if source_path.is_none() {
-                            source_path = Some(skill_path);
-                        }
-                        let app_str = match app {
-                            AppType::Claude => "claude",
-                            AppType::Codex => "codex",
-                            AppType::Gemini => "gemini",
-                            AppType::OpenCode => "opencode",
-                        };
-                        found_in.push(app_str.to_string());
+            for (base, label) in &search_sources {
+                let skill_path = base.join(&dir_name);
+                if skill_path.exists() {
+                    if source_path.is_none() {
+                        source_path = Some(skill_path);
                     }
+                    found_in.push(label.clone());
                 }
             }
 
@@ -630,40 +789,25 @@ impl SkillService {
 
             // 解析元数据
             let skill_md = dest.join("SKILL.md");
-            let (name, description) = if skill_md.exists() {
-                match Self::parse_skill_metadata_static(&skill_md) {
-                    Ok(meta) => (
-                        meta.name.unwrap_or_else(|| dir_name.clone()),
-                        meta.description,
-                    ),
-                    Err(_) => (dir_name.clone(), None),
-                }
-            } else {
-                (dir_name.clone(), None)
-            };
+            let (name, description) = Self::read_skill_name_desc(&skill_md, &dir_name);
 
             // 构建启用状态
-            let mut apps = SkillApps::default();
-            for app_str in &found_in {
-                match app_str.as_str() {
-                    "claude" => apps.claude = true,
-                    "codex" => apps.codex = true,
-                    "gemini" => apps.gemini = true,
-                    "opencode" => apps.opencode = true,
-                    _ => {}
-                }
-            }
+            let apps = SkillApps::from_labels(&found_in);
+
+            // 从 lock 文件提取仓库信息
+            let (id, repo_owner, repo_name, repo_branch, readme_url) =
+                build_repo_info_from_lock(&agents_lock, &dir_name);
 
             // 创建记录
             let skill = InstalledSkill {
-                id: format!("local:{dir_name}"),
+                id,
                 name,
                 description,
                 directory: dir_name,
-                repo_owner: None,
-                repo_name: None,
-                repo_branch: None,
-                readme_url: None,
+                repo_owner,
+                repo_name,
+                repo_branch,
+                readme_url,
                 apps,
                 installed_at: chrono::Utc::now().timestamp(),
             };
@@ -1047,6 +1191,79 @@ impl SkillService {
         Ok(meta)
     }
 
+    /// 从 SKILL.md 读取名称和描述，不存在则用目录名兜底
+    fn read_skill_name_desc(skill_md: &Path, fallback_name: &str) -> (String, Option<String>) {
+        if skill_md.exists() {
+            match Self::parse_skill_metadata_static(skill_md) {
+                Ok(meta) => (
+                    meta.name.unwrap_or_else(|| fallback_name.to_string()),
+                    meta.description,
+                ),
+                Err(_) => (fallback_name.to_string(), None),
+            }
+        } else {
+            (fallback_name.to_string(), None)
+        }
+    }
+
+    /// 校验并规范化技能源路径（允许多级目录），拒绝路径穿越和绝对路径
+    fn sanitize_skill_source_path(raw: &str) -> Option<PathBuf> {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+
+        let mut normalized = PathBuf::new();
+        let mut has_component = false;
+
+        for component in Path::new(trimmed).components() {
+            match component {
+                Component::Normal(name) => {
+                    let segment = name.to_string_lossy().trim().to_string();
+                    if segment.is_empty() || segment == "." || segment == ".." {
+                        return None;
+                    }
+                    normalized.push(segment);
+                    has_component = true;
+                }
+                Component::CurDir
+                | Component::ParentDir
+                | Component::RootDir
+                | Component::Prefix(_) => {
+                    return None;
+                }
+            }
+        }
+
+        has_component.then_some(normalized)
+    }
+
+    /// 校验并规范化安装目录名（最终落盘目录名，仅单段）
+    fn sanitize_install_name(raw: &str) -> Option<String> {
+        let trimmed = raw.trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+
+        let path = Path::new(trimmed);
+        let mut components = path.components();
+        match (components.next(), components.next()) {
+            (Some(Component::Normal(name)), None) => {
+                let normalized = name.to_string_lossy().trim().to_string();
+                if normalized.is_empty()
+                    || normalized == "."
+                    || normalized == ".."
+                    || normalized.starts_with('.')
+                {
+                    None
+                } else {
+                    Some(normalized)
+                }
+            }
+            _ => None,
+        }
+    }
+
     /// 去重技能列表（基于完整 key，不同仓库的同名 skill 分开显示）
     fn deduplicate_discoverable_skills(skills: &mut Vec<DiscoverableSkill>) {
         let mut seen = HashMap::new();
@@ -1070,7 +1287,7 @@ impl SkillService {
         let _ = temp_dir.keep();
 
         let mut branches = Vec::new();
-        if !repo.branch.is_empty() {
+        if !repo.branch.is_empty() && !repo.branch.eq_ignore_ascii_case("HEAD") {
             branches.push(repo.branch.as_str());
         }
         if !branches.contains(&"main") {
@@ -1135,9 +1352,12 @@ impl SkillService {
             )));
         };
 
+        // 第一遍：解压普通文件和目录，收集 symlink 条目
+        let mut symlinks: Vec<(PathBuf, String)> = Vec::new();
+
         for i in 0..archive.len() {
             let mut file = archive.by_index(i)?;
-            let file_path = file.name();
+            let file_path = file.name().to_string();
 
             let relative_path =
                 if let Some(stripped) = file_path.strip_prefix(&format!("{root_name}/")) {
@@ -1152,7 +1372,12 @@ impl SkillService {
 
             let outpath = dest.join(relative_path);
 
-            if file.is_dir() {
+            if file.is_symlink() {
+                // 读取 symlink 目标路径
+                let mut target = String::new();
+                std::io::Read::read_to_string(&mut file, &mut target)?;
+                symlinks.push((outpath, target.trim().to_string()));
+            } else if file.is_dir() {
                 fs::create_dir_all(&outpath)?;
             } else {
                 if let Some(parent) = outpath.parent() {
@@ -1163,6 +1388,9 @@ impl SkillService {
             }
         }
 
+        // 第二遍：解析 symlink，将目标内容复制到 symlink 位置
+        Self::resolve_symlinks_in_dir(dest, &symlinks)?;
+
         Ok(())
     }
 
@@ -1185,6 +1413,58 @@ impl SkillService {
         Ok(())
     }
 
+    /// 解析 ZIP 中的符号链接：将目标内容复制到 symlink 位置
+    ///
+    /// GitHub ZIP 归档保留了 symlink 元数据，解压时可通过 `is_symlink()` 检测。
+    /// 此方法将 symlink 解析为实际文件/目录内容（而非创建真实 symlink），
+    /// 以确保跨平台兼容且 skill 内容自包含。
+    fn resolve_symlinks_in_dir(base_dir: &Path, symlinks: &[(PathBuf, String)]) -> Result<()> {
+        // 规范化 base_dir（macOS 上 /tmp → /private/tmp，需保持一致）
+        let canonical_base = base_dir
+            .canonicalize()
+            .unwrap_or_else(|_| base_dir.to_path_buf());
+
+        for (link_path, target) in symlinks {
+            // 计算 symlink 的父目录，然后拼接目标的相对路径
+            let parent = link_path.parent().unwrap_or(base_dir);
+            let resolved = parent.join(target);
+
+            // 规范化路径（解析 .. 等）
+            let resolved = match resolved.canonicalize() {
+                Ok(p) => p,
+                Err(_) => {
+                    log::warn!(
+                        "Symlink 目标不存在，跳过: {} -> {}",
+                        link_path.display(),
+                        target
+                    );
+                    continue;
+                }
+            };
+
+            // 安全检查：确保目标在 base_dir 内（防止路径穿越）
+            if !resolved.starts_with(&canonical_base) {
+                log::warn!(
+                    "Symlink 目标超出仓库范围，跳过: {} -> {}",
+                    link_path.display(),
+                    resolved.display()
+                );
+                continue;
+            }
+
+            // 复制目标内容到 symlink 位置
+            if resolved.is_dir() {
+                Self::copy_dir_recursive(&resolved, link_path)?;
+            } else if resolved.is_file() {
+                if let Some(parent) = link_path.parent() {
+                    fs::create_dir_all(parent)?;
+                }
+                fs::copy(&resolved, link_path)?;
+            }
+        }
+        Ok(())
+    }
+
     // ========== 从 ZIP 文件安装 ==========
 
     /// 从本地 ZIP 文件安装 Skills
@@ -1217,13 +1497,56 @@ impl SkillService {
         let ssot_dir = Self::get_ssot_dir()?;
         let mut installed = Vec::new();
         let existing_skills = db.get_all_installed_skills()?;
+        let zip_stem = zip_path
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .map(|s| s.to_string());
 
         for skill_dir in skill_dirs {
+            // 解析元数据（提前解析，用于确定安装名）
+            let skill_md = skill_dir.join("SKILL.md");
+            let meta = if skill_md.exists() {
+                Self::parse_skill_metadata_static(&skill_md).ok()
+            } else {
+                None
+            };
+
             // 获取目录名称作为安装名
-            let install_name = skill_dir
-                .file_name()
-                .map(|s| s.to_string_lossy().to_string())
-                .unwrap_or_else(|| "unknown".to_string());
+            // 当 SKILL.md 在 ZIP 根目录时，skill_dir == temp_dir，
+            // file_name() 会返回临时目录名（如 .tmpDZKGpF），需要回退到其他来源
+            let install_name = {
+                let dir_name = skill_dir
+                    .file_name()
+                    .map(|s| s.to_string_lossy().to_string())
+                    .unwrap_or_default();
+
+                if skill_dir == temp_dir || dir_name.is_empty() || dir_name.starts_with('.') {
+                    // SKILL.md 在根目录：优先用元数据 name，否则用 ZIP 文件名
+                    meta.as_ref()
+                        .and_then(|m| m.name.as_deref())
+                        .and_then(Self::sanitize_install_name)
+                        .or_else(|| zip_stem.as_deref().and_then(Self::sanitize_install_name))
+                } else {
+                    Self::sanitize_install_name(&dir_name)
+                        .or_else(|| {
+                            meta.as_ref()
+                                .and_then(|m| m.name.as_deref())
+                                .and_then(Self::sanitize_install_name)
+                        })
+                        .or_else(|| zip_stem.as_deref().and_then(Self::sanitize_install_name))
+                }
+            };
+            let install_name = match install_name {
+                Some(name) => name,
+                None => {
+                    let _ = fs::remove_dir_all(&temp_dir);
+                    return Err(anyhow!(format_skill_error(
+                        "INVALID_SKILL_DIRECTORY",
+                        &[("zip", &zip_path.display().to_string())],
+                        Some("checkZipContent"),
+                    )));
+                }
+            };
 
             // 检查是否已有同名 directory 的 skill
             let conflict = existing_skills
@@ -1239,18 +1562,12 @@ impl SkillService {
                 continue;
             }
 
-            // 解析元数据
-            let skill_md = skill_dir.join("SKILL.md");
-            let (name, description) = if skill_md.exists() {
-                match Self::parse_skill_metadata_static(&skill_md) {
-                    Ok(meta) => (
-                        meta.name.unwrap_or_else(|| install_name.clone()),
-                        meta.description,
-                    ),
-                    Err(_) => (install_name.clone(), None),
-                }
-            } else {
-                (install_name.clone(), None)
+            let (name, description) = match meta {
+                Some(m) => (
+                    m.name.unwrap_or_else(|| install_name.clone()),
+                    m.description,
+                ),
+                None => (install_name.clone(), None),
             };
 
             // 复制到 SSOT
@@ -1314,6 +1631,8 @@ impl SkillService {
         let temp_path = temp_dir.path().to_path_buf();
         let _ = temp_dir.keep(); // Keep the directory, we'll clean up later
 
+        let mut symlinks: Vec<(PathBuf, String)> = Vec::new();
+
         for i in 0..archive.len() {
             let mut file = archive.by_index(i)?;
             let file_path = match file.enclosed_name() {
@@ -1323,7 +1642,11 @@ impl SkillService {
 
             let outpath = temp_path.join(&file_path);
 
-            if file.is_dir() {
+            if file.is_symlink() {
+                let mut target = String::new();
+                std::io::Read::read_to_string(&mut file, &mut target)?;
+                symlinks.push((outpath, target.trim().to_string()));
+            } else if file.is_dir() {
                 fs::create_dir_all(&outpath)?;
             } else {
                 if let Some(parent) = outpath.parent() {
@@ -1334,6 +1657,9 @@ impl SkillService {
             }
         }
 
+        // 解析 symlink
+        Self::resolve_symlinks_in_dir(&temp_path, &symlinks)?;
+
         Ok(temp_path)
     }
 
@@ -1406,38 +1732,109 @@ impl SkillService {
 
 // ========== 迁移支持 ==========
 
+/// 从 lock 文件信息构建 skill 的 ID、仓库字段和 readme URL
+///
+/// 返回 (id, repo_owner, repo_name, repo_branch, readme_url)
+fn build_repo_info_from_lock(
+    lock: &HashMap<String, LockRepoInfo>,
+    dir_name: &str,
+) -> (
+    String,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+    Option<String>,
+) {
+    match lock.get(dir_name) {
+        Some(info) => {
+            let branch = info.branch.clone();
+            let url_branch = branch.clone().unwrap_or_else(|| "HEAD".to_string());
+            // 优先使用 lock 文件中的 skillPath，否则回退到 dir_name/SKILL.md
+            let fallback = format!("{dir_name}/SKILL.md");
+            let doc_path = info.skill_path.as_deref().unwrap_or(&fallback);
+            let url = Some(SkillService::build_skill_doc_url(
+                &info.owner,
+                &info.repo,
+                &url_branch,
+                doc_path,
+            ));
+            (
+                format!("{}/{}:{dir_name}", info.owner, info.repo),
+                Some(info.owner.clone()),
+                Some(info.repo.clone()),
+                branch,
+                url,
+            )
+        }
+        None => (format!("local:{dir_name}"), None, None, None, None),
+    }
+}
+
+/// 将 lock 文件中发现的仓库保存到 skill_repos（去重）
+fn save_repos_from_lock(
+    db: &Arc<Database>,
+    lock: &HashMap<String, LockRepoInfo>,
+    directories: impl Iterator<Item = impl AsRef<str>>,
+) {
+    let existing_repos: HashSet<(String, String)> = db
+        .get_skill_repos()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|r| (r.owner, r.name))
+        .collect();
+    let mut added = HashSet::new();
+
+    for dir_name in directories {
+        if let Some(info) = lock.get(dir_name.as_ref()) {
+            let key = (info.owner.clone(), info.repo.clone());
+            if !existing_repos.contains(&key) && added.insert(key) {
+                let skill_repo = SkillRepo {
+                    owner: info.owner.clone(),
+                    name: info.repo.clone(),
+                    // 未知分支时使用 HEAD 语义，后续下载会回退到 main/master。
+                    branch: info.branch.clone().unwrap_or_else(|| "HEAD".to_string()),
+                    enabled: true,
+                };
+                if let Err(e) = db.save_skill_repo(&skill_repo) {
+                    log::warn!("保存 skill 仓库 {}/{} 失败: {}", info.owner, info.repo, e);
+                } else {
+                    log::info!(
+                        "从 agents lock 文件发现并添加仓库: {}/{} ({})",
+                        info.owner,
+                        info.repo,
+                        skill_repo.branch
+                    );
+                }
+            }
+        }
+    }
+}
+
 /// 首次启动迁移：扫描应用目录，重建数据库
 pub fn migrate_skills_to_ssot(db: &Arc<Database>) -> Result<usize> {
     let ssot_dir = SkillService::get_ssot_dir()?;
+    let agents_lock = parse_agents_lock();
     let mut discovered: HashMap<String, SkillApps> = HashMap::new();
 
     // 扫描各应用目录
-    for app in [
-        AppType::Claude,
-        AppType::Codex,
-        AppType::Gemini,
-        AppType::OpenCode,
-    ] {
+    for app in AppType::all() {
         let app_dir = match SkillService::get_app_skills_dir(&app) {
             Ok(d) => d,
             Err(_) => continue,
         };
 
-        if !app_dir.exists() {
-            continue;
-        }
+        let entries = match fs::read_dir(&app_dir) {
+            Ok(e) => e,
+            Err(_) => continue,
+        };
 
-        for entry in fs::read_dir(&app_dir)? {
-            let entry = entry?;
+        for entry in entries.flatten() {
             let path = entry.path();
-
             if !path.is_dir() {
                 continue;
             }
 
             let dir_name = entry.file_name().to_string_lossy().to_string();
-
-            // 跳过隐藏目录（以 . 开头，如 .system）
             if dir_name.starts_with('.') {
                 continue;
             }
@@ -1448,7 +1845,6 @@ pub fn migrate_skills_to_ssot(db: &Arc<Database>) -> Result<usize> {
                 SkillService::copy_dir_recursive(&path, &ssot_path)?;
             }
 
-            // 记录启用状态
             discovered
                 .entry(dir_name)
                 .or_default()
@@ -1459,32 +1855,28 @@ pub fn migrate_skills_to_ssot(db: &Arc<Database>) -> Result<usize> {
     // 重建数据库
     db.clear_skills()?;
 
+    // 将 lock 文件中发现的仓库保存到 skill_repos
+    save_repos_from_lock(db, &agents_lock, discovered.keys());
+
     let mut count = 0;
     for (directory, apps) in discovered {
         let ssot_path = ssot_dir.join(&directory);
         let skill_md = ssot_path.join("SKILL.md");
 
-        let (name, description) = if skill_md.exists() {
-            match SkillService::parse_skill_metadata_static(&skill_md) {
-                Ok(meta) => (
-                    meta.name.unwrap_or_else(|| directory.clone()),
-                    meta.description,
-                ),
-                Err(_) => (directory.clone(), None),
-            }
-        } else {
-            (directory.clone(), None)
-        };
+        let (name, description) = SkillService::read_skill_name_desc(&skill_md, &directory);
+
+        let (id, repo_owner, repo_name, repo_branch, readme_url) =
+            build_repo_info_from_lock(&agents_lock, &directory);
 
         let skill = InstalledSkill {
-            id: format!("local:{directory}"),
+            id,
             name,
             description,
             directory,
-            repo_owner: None,
-            repo_name: None,
-            repo_branch: None,
-            readme_url: None,
+            repo_owner,
+            repo_name,
+            repo_branch,
+            readme_url,
             apps,
             installed_at: chrono::Utc::now().timestamp(),
         };

src-tauri/src/services/stream_check.rs

@@ -240,6 +240,14 @@ impl StreamCheckService {
                     "OpenCode does not support health check yet",
                 ));
             }
+            AppType::OpenClaw => {
+                // OpenClaw doesn't support stream check yet
+                return Err(AppError::localized(
+                    "openclaw_no_stream_check",
+                    "OpenClaw 暂不支持健康检查",
+                    "OpenClaw does not support health check yet",
+                ));
+            }
         };
 
         let response_time = start.elapsed().as_millis() as u64;
@@ -567,6 +575,11 @@ impl StreamCheckService {
                 // Try to extract first model from the models object
                 Self::extract_opencode_model(provider).unwrap_or_else(|| "gpt-4o".to_string())
             }
+            AppType::OpenClaw => {
+                // OpenClaw uses models array in settings_config
+                // Try to extract first model from the models array
+                Self::extract_openclaw_model(provider).unwrap_or_else(|| "gpt-4o".to_string())
+            }
         }
     }
 
@@ -580,6 +593,21 @@ impl StreamCheckService {
         models.keys().next().map(|s| s.to_string())
     }
 
+    fn extract_openclaw_model(provider: &Provider) -> Option<String> {
+        // OpenClaw uses models array: [{ "id": "model-id", "name": "Model Name" }]
+        let models = provider
+            .settings_config
+            .get("models")
+            .and_then(|m| m.as_array())?;
+
+        // Return the first model ID from the models array
+        models
+            .first()
+            .and_then(|m| m.get("id"))
+            .and_then(|id| id.as_str())
+            .map(|s| s.to_string())
+    }
+
     fn extract_env_model(provider: &Provider, key: &str) -> Option<String> {
         provider
             .settings_config

src-tauri/src/services/webdav.rs

@@ -0,0 +1,552 @@
+//! WebDAV HTTP transport layer.
+//!
+//! Low-level HTTP primitives for WebDAV operations (PUT, GET, HEAD, MKCOL, PROPFIND).
+//! The sync protocol logic lives in [`super::webdav_sync`].
+
+use reqwest::{Method, RequestBuilder, StatusCode, Url};
+use std::time::Duration;
+
+use crate::error::AppError;
+use crate::proxy::http_client;
+use futures::StreamExt;
+
+const DEFAULT_TIMEOUT_SECS: u64 = 30;
+/// Timeout for large file transfers (PUT/GET of db.sql, skills.zip).
+const TRANSFER_TIMEOUT_SECS: u64 = 300;
+
+/// Auth pair: `(username, Some(password))`.
+pub type WebDavAuth = Option<(String, Option<String>)>;
+
+// ─── WebDAV extension methods ────────────────────────────────
+
+fn method_propfind() -> Method {
+    Method::from_bytes(b"PROPFIND").expect("PROPFIND is a valid HTTP method")
+}
+
+fn method_mkcol() -> Method {
+    Method::from_bytes(b"MKCOL").expect("MKCOL is a valid HTTP method")
+}
+
+// ─── URL utilities ───────────────────────────────────────────
+
+/// Parse and validate a WebDAV base URL (must be http or https).
+pub fn parse_base_url(raw: &str) -> Result<Url, AppError> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return Err(AppError::localized(
+            "webdav.base_url.required",
+            "WebDAV 地址不能为空",
+            "WebDAV URL is required.",
+        ));
+    }
+    let url = Url::parse(trimmed).map_err(|e| {
+        AppError::localized(
+            "webdav.base_url.invalid",
+            format!("WebDAV 地址无效: {e}"),
+            format!("Invalid WebDAV URL: {e}"),
+        )
+    })?;
+    match url.scheme() {
+        "http" | "https" => Ok(url),
+        _ => Err(AppError::localized(
+            "webdav.base_url.scheme_invalid",
+            "WebDAV 仅支持 http/https 地址",
+            "WebDAV URL must use http or https.",
+        )),
+    }
+}
+
+/// Build a full URL from a base URL string and path segments.
+///
+/// Each segment is individually percent-encoded by the `url` crate.
+pub fn build_remote_url(base_url: &str, segments: &[String]) -> Result<String, AppError> {
+    let mut url = parse_base_url(base_url)?;
+    {
+        let mut path = url.path_segments_mut().map_err(|_| {
+            AppError::localized(
+                "webdav.base_url.unusable",
+                "WebDAV 地址格式不支持追加路径",
+                "WebDAV URL format does not support appending path segments.",
+            )
+        })?;
+        path.pop_if_empty();
+        for seg in segments {
+            path.push(seg);
+        }
+    }
+    Ok(url.to_string())
+}
+
+/// Split a slash-delimited path into non-empty segments.
+pub fn path_segments(raw: &str) -> impl Iterator<Item = &str> {
+    raw.trim_matches('/').split('/').filter(|s| !s.is_empty())
+}
+
+// ─── Auth ────────────────────────────────────────────────────
+
+/// Build auth from username/password. Returns `None` if username is blank.
+pub fn auth_from_credentials(username: &str, password: &str) -> WebDavAuth {
+    let user = username.trim();
+    if user.is_empty() {
+        return None;
+    }
+    Some((user.to_string(), Some(password.to_string())))
+}
+
+/// Apply Basic-Auth to a request builder if auth is present.
+fn apply_auth(builder: RequestBuilder, auth: &WebDavAuth) -> RequestBuilder {
+    match auth {
+        Some((user, pass)) => builder.basic_auth(user, pass.as_deref()),
+        None => builder,
+    }
+}
+
+fn webdav_transport_error(
+    key: &'static str,
+    op_zh: &str,
+    op_en: &str,
+    target_url: &str,
+    err: &reqwest::Error,
+) -> AppError {
+    let (zh_reason, en_reason) = if err.is_timeout() {
+        ("请求超时", "request timed out")
+    } else if err.is_connect() {
+        ("连接失败", "connection failed")
+    } else if err.is_request() {
+        ("请求构造失败", "request build failed")
+    } else {
+        ("网络请求失败", "network request failed")
+    };
+
+    let safe_url = redact_url(target_url);
+    AppError::localized(
+        key,
+        format!("WebDAV {op_zh}失败（{zh_reason}）: {safe_url}"),
+        format!("WebDAV {op_en} failed ({en_reason}): {safe_url}"),
+    )
+}
+
+// ─── HTTP operations ─────────────────────────────────────────
+
+/// Test WebDAV connectivity via PROPFIND Depth=0 on the base URL.
+pub async fn test_connection(base_url: &str, auth: &WebDavAuth) -> Result<(), AppError> {
+    let url = parse_base_url(base_url)?;
+    let client = http_client::get();
+
+    let resp = apply_auth(
+        client
+            .request(method_propfind(), url)
+            .header("Depth", "0")
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECS)),
+        auth,
+    )
+    .send()
+    .await
+    .map_err(|e| {
+        webdav_transport_error(
+            "webdav.connection_failed",
+            "连接",
+            "connection",
+            base_url,
+            &e,
+        )
+    })?;
+
+    if resp.status().is_success() || resp.status() == StatusCode::MULTI_STATUS {
+        return Ok(());
+    }
+    Err(webdav_status_error("PROPFIND", resp.status(), base_url))
+}
+
+/// Ensure a chain of remote directories exists.
+///
+/// Uses optimistic MKCOL: try creating first, fall back to PROPFIND verification
+/// on ambiguous responses. This halves the round-trips vs PROPFIND-first approach.
+pub async fn ensure_remote_directories(
+    base_url: &str,
+    segments: &[String],
+    auth: &WebDavAuth,
+) -> Result<(), AppError> {
+    if segments.is_empty() {
+        return Ok(());
+    }
+    let client = http_client::get();
+
+    for depth in 1..=segments.len() {
+        let prefix = &segments[..depth];
+        let url = build_remote_url(base_url, prefix)?;
+        let dir_url = if url.ends_with('/') {
+            url
+        } else {
+            format!("{url}/")
+        };
+
+        let resp = apply_auth(
+            client
+                .request(method_mkcol(), &dir_url)
+                .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECS)),
+            auth,
+        )
+        .send()
+        .await
+        .map_err(|e| {
+            webdav_transport_error(
+                "webdav.mkcol_failed",
+                "MKCOL 请求",
+                "MKCOL request",
+                &dir_url,
+                &e,
+            )
+        })?;
+
+        let status = resp.status();
+        match status {
+            s if s == StatusCode::CREATED || s.is_success() => {
+                log::info!("[WebDAV] MKCOL ok: {}", redact_url(&dir_url));
+            }
+            // 405 commonly means "already exists" on many WebDAV servers
+            StatusCode::METHOD_NOT_ALLOWED => {}
+            // Ambiguous — verify directory actually exists via PROPFIND
+            s if s == StatusCode::CONFLICT || s.is_redirection() => {
+                if !propfind_exists(&client, &dir_url, auth).await? {
+                    return Err(webdav_status_error("MKCOL", status, &dir_url));
+                }
+            }
+            _ => {
+                return Err(webdav_status_error("MKCOL", status, &dir_url));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// PUT bytes to a remote WebDAV URL.
+pub async fn put_bytes(
+    url: &str,
+    auth: &WebDavAuth,
+    bytes: Vec<u8>,
+    content_type: &str,
+) -> Result<(), AppError> {
+    let client = http_client::get();
+    let resp = apply_auth(
+        client
+            .put(url)
+            .header("Content-Type", content_type)
+            .body(bytes)
+            .timeout(Duration::from_secs(TRANSFER_TIMEOUT_SECS)),
+        auth,
+    )
+    .send()
+    .await
+    .map_err(|e| webdav_transport_error("webdav.put_failed", "PUT 请求", "PUT request", url, &e))?;
+
+    if resp.status().is_success() {
+        return Ok(());
+    }
+    Err(webdav_status_error("PUT", resp.status(), url))
+}
+
+/// GET bytes from a remote WebDAV URL. Returns `None` on 404.
+///
+/// On success returns `(body_bytes, optional_etag)`.
+pub async fn get_bytes(
+    url: &str,
+    auth: &WebDavAuth,
+    max_bytes: usize,
+) -> Result<Option<(Vec<u8>, Option<String>)>, AppError> {
+    let client = http_client::get();
+    let resp = apply_auth(
+        client
+            .get(url)
+            .timeout(Duration::from_secs(TRANSFER_TIMEOUT_SECS)),
+        auth,
+    )
+    .send()
+    .await
+    .map_err(|e| webdav_transport_error("webdav.get_failed", "GET 请求", "GET request", url, &e))?;
+
+    if resp.status() == StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+    if !resp.status().is_success() {
+        return Err(webdav_status_error("GET", resp.status(), url));
+    }
+    ensure_content_length_within_limit(resp.headers(), max_bytes, url)?;
+
+    let etag = resp
+        .headers()
+        .get("etag")
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_string());
+    let mut bytes = Vec::new();
+    let mut stream = resp.bytes_stream();
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk.map_err(|e| {
+            AppError::localized(
+                "webdav.response_read_failed",
+                format!("读取 WebDAV 响应失败: {e}"),
+                format!("Failed to read WebDAV response: {e}"),
+            )
+        })?;
+        if bytes.len().saturating_add(chunk.len()) > max_bytes {
+            return Err(response_too_large_error(url, max_bytes));
+        }
+        bytes.extend_from_slice(&chunk);
+    }
+    Ok(Some((bytes, etag)))
+}
+
+/// HEAD request to retrieve the ETag. Returns `None` on 404.
+pub async fn head_etag(url: &str, auth: &WebDavAuth) -> Result<Option<String>, AppError> {
+    let client = http_client::get();
+    let resp = apply_auth(
+        client
+            .head(url)
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECS)),
+        auth,
+    )
+    .send()
+    .await
+    .map_err(|e| {
+        webdav_transport_error("webdav.head_failed", "HEAD 请求", "HEAD request", url, &e)
+    })?;
+
+    if resp.status() == StatusCode::NOT_FOUND {
+        return Ok(None);
+    }
+    if !resp.status().is_success() {
+        return Err(webdav_status_error("HEAD", resp.status(), url));
+    }
+    Ok(resp
+        .headers()
+        .get("etag")
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_string()))
+}
+
+// ─── Internal helpers ────────────────────────────────────────
+
+/// PROPFIND Depth=0 to check if a remote resource exists.
+async fn propfind_exists(
+    client: &reqwest::Client,
+    url: &str,
+    auth: &WebDavAuth,
+) -> Result<bool, AppError> {
+    let resp = apply_auth(
+        client
+            .request(method_propfind(), url)
+            .header("Depth", "0")
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECS)),
+        auth,
+    )
+    .send()
+    .await;
+    match resp {
+        Ok(r) => Ok(r.status().is_success() || r.status() == StatusCode::MULTI_STATUS),
+        Err(e) => {
+            log::warn!(
+                "[WebDAV] PROPFIND check failed for {}: {e}",
+                redact_url(url)
+            );
+            Ok(false)
+        }
+    }
+}
+
+// ─── Service detection & error helpers ───────────────────────
+
+/// Check if a URL points to Jianguoyun (坚果云).
+pub fn is_jianguoyun(url: &str) -> bool {
+    Url::parse(url)
+        .ok()
+        .and_then(|u| u.host_str().map(|h| h.to_lowercase()))
+        .map(|host| host.contains("jianguoyun.com") || host.contains("nutstore"))
+        .unwrap_or(false)
+}
+
+/// Build an `AppError` with service-specific hints for WebDAV failures.
+pub fn webdav_status_error(op: &str, status: StatusCode, url: &str) -> AppError {
+    let safe_url = redact_url(url);
+    let mut zh = format!("WebDAV {op} 失败: {status} ({safe_url})");
+    let mut en = format!("WebDAV {op} failed: {status} ({safe_url})");
+    let jgy = is_jianguoyun(url);
+
+    if matches!(status, StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN) {
+        if jgy {
+            zh.push_str("。坚果云请使用「第三方应用密码」，并确认地址指向 /dav/ 下的目录。");
+            en.push_str(
+                ". For Jianguoyun, use an app-specific password and ensure the URL points under /dav/.",
+            );
+        } else {
+            zh.push_str("。请检查 WebDAV 用户名、密码及目录读写权限。");
+            en.push_str(". Please check WebDAV username/password and directory permissions.");
+        }
+    } else if jgy && (status == StatusCode::NOT_FOUND || status.is_redirection()) {
+        zh.push_str("。坚果云常见原因：地址不在 /dav/ 可写目录下。");
+        en.push_str(". Common Jianguoyun cause: URL is outside a writable /dav/ directory.");
+    } else if op == "MKCOL" && status == StatusCode::CONFLICT {
+        if jgy {
+            zh.push_str("。坚果云不允许自动创建顶层文件夹，请先在网页端手动创建后重试。");
+            en.push_str(
+                ". Jianguoyun does not allow creating top-level folders automatically; create it manually first.",
+            );
+        } else {
+            zh.push_str("。请确认上级目录存在。");
+            en.push_str(". Please ensure the parent directory exists.");
+        }
+    }
+
+    AppError::localized("webdav.http.status", zh, en)
+}
+
+fn redact_url(raw: &str) -> String {
+    match Url::parse(raw) {
+        Ok(mut parsed) => {
+            let _ = parsed.set_username("");
+            let _ = parsed.set_password(None);
+
+            let mut out = format!("{}://", parsed.scheme());
+            if let Some(host) = parsed.host_str() {
+                out.push_str(host);
+            }
+            if let Some(port) = parsed.port() {
+                out.push(':');
+                out.push_str(&port.to_string());
+            }
+            out.push_str(parsed.path());
+
+            let mut keys: Vec<String> = parsed.query_pairs().map(|(k, _)| k.into_owned()).collect();
+            keys.sort();
+            keys.dedup();
+            if !keys.is_empty() {
+                out.push_str("?[keys:");
+                out.push_str(&keys.join(","));
+                out.push(']');
+            }
+            out
+        }
+        Err(_) => raw.split('?').next().unwrap_or(raw).to_string(),
+    }
+}
+
+fn response_too_large_error(url: &str, max_bytes: usize) -> AppError {
+    let max_mb = max_bytes / 1024 / 1024;
+    AppError::localized(
+        "webdav.response_too_large",
+        format!(
+            "WebDAV 响应体超过上限（{} MB）: {}",
+            max_mb,
+            redact_url(url)
+        ),
+        format!(
+            "WebDAV response body exceeds limit ({} MB): {}",
+            max_mb,
+            redact_url(url)
+        ),
+    )
+}
+
+fn ensure_content_length_within_limit(
+    headers: &reqwest::header::HeaderMap,
+    max_bytes: usize,
+    url: &str,
+) -> Result<(), AppError> {
+    let Some(content_length) = headers.get(reqwest::header::CONTENT_LENGTH) else {
+        return Ok(());
+    };
+    let Ok(raw) = content_length.to_str() else {
+        return Ok(());
+    };
+    let Ok(value) = raw.parse::<u64>() else {
+        return Ok(());
+    };
+    if value > max_bytes as u64 {
+        return Err(response_too_large_error(url, max_bytes));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reqwest::header::{HeaderMap, HeaderValue, CONTENT_LENGTH};
+
+    #[test]
+    fn build_remote_url_encodes_path_segments() {
+        let url = build_remote_url(
+            "https://dav.example.com/remote.php/dav/files/demo/",
+            &[
+                "cc switch-sync".to_string(),
+                "v2".to_string(),
+                "default profile".to_string(),
+                "manifest.json".to_string(),
+            ],
+        )
+        .unwrap();
+        assert_eq!(
+            url,
+            "https://dav.example.com/remote.php/dav/files/demo/cc%20switch-sync/v2/default%20profile/manifest.json"
+        );
+        assert!(!url.contains("//cc"), "should not have double-slash");
+    }
+
+    #[test]
+    fn is_jianguoyun_detects_correctly() {
+        assert!(is_jianguoyun("https://dav.jianguoyun.com/dav"));
+        assert!(is_jianguoyun("https://dav.jianguoyun.com/dav/folder"));
+        assert!(!is_jianguoyun("https://nextcloud.example.com/dav"));
+    }
+
+    #[test]
+    fn path_segments_splits_correctly() {
+        let segs: Vec<_> = path_segments("/a/b/c/").collect();
+        assert_eq!(segs, vec!["a", "b", "c"]);
+
+        let segs: Vec<_> = path_segments("single").collect();
+        assert_eq!(segs, vec!["single"]);
+
+        let segs: Vec<_> = path_segments("").collect();
+        assert!(segs.is_empty());
+    }
+
+    #[test]
+    fn auth_from_credentials_trims_and_rejects_blank() {
+        assert!(auth_from_credentials("  ", "pass").is_none());
+        let auth = auth_from_credentials(" user ", "pass");
+        assert_eq!(auth, Some(("user".to_string(), Some("pass".to_string()))));
+    }
+
+    #[test]
+    fn redact_url_hides_credentials_and_query_values() {
+        let redacted = redact_url("https://alice:secret@example.com:8443/dav?token=abc&foo=1");
+        assert_eq!(redacted, "https://example.com:8443/dav?[keys:foo,token]");
+        assert!(!redacted.contains("secret"));
+    }
+
+    #[test]
+    fn ensure_content_length_within_limit_accepts_missing_or_small_values() {
+        let empty = HeaderMap::new();
+        assert!(
+            ensure_content_length_within_limit(&empty, 1024, "https://dav.example.com").is_ok()
+        );
+
+        let mut small = HeaderMap::new();
+        small.insert(CONTENT_LENGTH, HeaderValue::from_static("1024"));
+        assert!(
+            ensure_content_length_within_limit(&small, 1024, "https://dav.example.com").is_ok()
+        );
+    }
+
+    #[test]
+    fn ensure_content_length_within_limit_rejects_oversized_values() {
+        let mut large = HeaderMap::new();
+        large.insert(CONTENT_LENGTH, HeaderValue::from_static("2048"));
+
+        let err = ensure_content_length_within_limit(&large, 1024, "https://dav.example.com")
+            .expect_err("oversized response should be rejected");
+        assert!(
+            err.to_string().contains("too large") || err.to_string().contains("超过"),
+            "unexpected error: {err}"
+        );
+    }
+}

src-tauri/src/services/webdav_auto_sync.rs

@@ -0,0 +1,277 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::sync::OnceLock;
+use std::time::{Duration, Instant};
+
+use serde_json::json;
+use tauri::{AppHandle, Emitter};
+use tokio::sync::mpsc::error::TrySendError;
+use tokio::sync::mpsc::{channel, Receiver, Sender};
+
+use crate::error::AppError;
+use crate::services::webdav_sync as webdav_sync_service;
+use crate::settings::{self, WebDavSyncSettings};
+
+const AUTO_SYNC_DEBOUNCE_MS: u64 = 1000;
+pub(crate) const MAX_AUTO_SYNC_WAIT_MS: u64 = 10_000;
+
+static DB_CHANGE_TX: OnceLock<Sender<String>> = OnceLock::new();
+static AUTO_SYNC_SUPPRESS_DEPTH: AtomicUsize = AtomicUsize::new(0);
+
+pub(crate) struct AutoSyncSuppressionGuard;
+
+impl AutoSyncSuppressionGuard {
+    pub fn new() -> Self {
+        AUTO_SYNC_SUPPRESS_DEPTH.fetch_add(1, Ordering::SeqCst);
+        Self
+    }
+}
+
+impl Drop for AutoSyncSuppressionGuard {
+    fn drop(&mut self) {
+        let _ =
+            AUTO_SYNC_SUPPRESS_DEPTH.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
+                Some(value.saturating_sub(1))
+            });
+    }
+}
+
+pub(crate) fn is_auto_sync_suppressed() -> bool {
+    AUTO_SYNC_SUPPRESS_DEPTH.load(Ordering::SeqCst) > 0
+}
+
+pub fn should_trigger_for_table(table: &str) -> bool {
+    let normalized = table.trim().to_ascii_lowercase();
+    matches!(
+        normalized.as_str(),
+        "providers"
+            | "provider_endpoints"
+            | "mcp_servers"
+            | "prompts"
+            | "skills"
+            | "skill_repos"
+            | "settings"
+            | "proxy_config"
+    )
+}
+
+pub(crate) fn enqueue_change_signal(tx: &Sender<String>, table: &str) -> bool {
+    match tx.try_send(table.to_string()) {
+        Ok(()) => true,
+        Err(TrySendError::Full(_)) | Err(TrySendError::Closed(_)) => false,
+    }
+}
+
+pub(crate) fn auto_sync_wait_duration(started_at: Instant, now: Instant) -> Option<Duration> {
+    let max_wait = Duration::from_millis(MAX_AUTO_SYNC_WAIT_MS);
+    let debounce = Duration::from_millis(AUTO_SYNC_DEBOUNCE_MS);
+    let elapsed = now.saturating_duration_since(started_at);
+    if elapsed >= max_wait {
+        return None;
+    }
+    Some(debounce.min(max_wait - elapsed))
+}
+
+fn should_run_auto_sync(settings: Option<&WebDavSyncSettings>) -> bool {
+    let Some(sync) = settings else {
+        return false;
+    };
+    sync.enabled && sync.auto_sync
+}
+
+fn persist_auto_sync_error(settings: &mut WebDavSyncSettings, error: &AppError) {
+    settings.status.last_error = Some(error.to_string());
+    settings.status.last_error_source = Some("auto".to_string());
+    let _ = settings::update_webdav_sync_status(settings.status.clone());
+}
+
+fn emit_auto_sync_status_updated(app: &AppHandle, status: &str, error: Option<&str>) {
+    let payload = match error {
+        Some(message) => json!({
+            "source": "auto",
+            "status": status,
+            "error": message,
+        }),
+        None => json!({
+            "source": "auto",
+            "status": status,
+        }),
+    };
+
+    if let Err(err) = app.emit("webdav-sync-status-updated", payload) {
+        log::debug!("[WebDAV] failed to emit sync status update event: {err}");
+    }
+}
+
+async fn run_auto_sync_upload(
+    db: &crate::database::Database,
+    app: &AppHandle,
+) -> Result<(), AppError> {
+    let mut settings = settings::get_webdav_sync_settings();
+    if !should_run_auto_sync(settings.as_ref()) {
+        return Ok(());
+    }
+
+    let mut sync_settings = match settings.take() {
+        Some(value) => value,
+        None => return Ok(()),
+    };
+
+    let result = webdav_sync_service::run_with_sync_lock(webdav_sync_service::upload(
+        db,
+        &mut sync_settings,
+    ))
+    .await;
+    match result {
+        Ok(_) => {
+            emit_auto_sync_status_updated(app, "success", None);
+            Ok(())
+        }
+        Err(err) => {
+            persist_auto_sync_error(&mut sync_settings, &err);
+            emit_auto_sync_status_updated(app, "error", Some(&err.to_string()));
+            Err(err)
+        }
+    }
+}
+
+pub fn notify_db_changed(table: &str) {
+    if is_auto_sync_suppressed() {
+        return;
+    }
+    if !should_trigger_for_table(table) {
+        return;
+    }
+    let Some(tx) = DB_CHANGE_TX.get() else {
+        return;
+    };
+    let _ = enqueue_change_signal(tx, table);
+}
+
+pub fn start_worker(db: Arc<crate::database::Database>, app: tauri::AppHandle) {
+    if DB_CHANGE_TX.get().is_some() {
+        return;
+    }
+
+    // Buffer size 1 is enough: we only need "dirty" signals, not every event.
+    let (tx, rx) = channel::<String>(1);
+    if DB_CHANGE_TX.set(tx).is_err() {
+        return;
+    }
+
+    tauri::async_runtime::spawn(async move {
+        run_worker_loop(db, rx, app).await;
+    });
+}
+
+async fn run_worker_loop(
+    db: Arc<crate::database::Database>,
+    mut rx: Receiver<String>,
+    app: tauri::AppHandle,
+) {
+    while let Some(first_table) = rx.recv().await {
+        let started_at = Instant::now();
+        let mut merged_count = 1usize;
+
+        loop {
+            let Some(wait_for) = auto_sync_wait_duration(started_at, Instant::now()) else {
+                break;
+            };
+            let timeout = tokio::time::timeout(wait_for, rx.recv()).await;
+
+            match timeout {
+                Ok(Some(_)) => merged_count += 1,
+                Ok(None) => return,
+                Err(_) => break,
+            }
+        }
+
+        log::debug!(
+            "[WebDAV][AutoSync] Triggered by table={first_table}, merged_changes={merged_count}"
+        );
+
+        if let Err(err) = run_auto_sync_upload(&db, &app).await {
+            log::warn!("[WebDAV][AutoSync] Upload failed: {err}");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        auto_sync_wait_duration, enqueue_change_signal, is_auto_sync_suppressed,
+        should_run_auto_sync, should_trigger_for_table, AutoSyncSuppressionGuard,
+        MAX_AUTO_SYNC_WAIT_MS,
+    };
+    use crate::settings::WebDavSyncSettings;
+    use std::time::{Duration, Instant};
+    use tokio::sync::mpsc::channel;
+
+    #[test]
+    fn should_trigger_sync_for_config_tables_only() {
+        assert!(should_trigger_for_table("providers"));
+        assert!(should_trigger_for_table("settings"));
+        assert!(!should_trigger_for_table("proxy_request_logs"));
+        assert!(!should_trigger_for_table("provider_health"));
+    }
+
+    #[test]
+    fn suppression_guard_enables_and_restores_state() {
+        assert!(!is_auto_sync_suppressed());
+        {
+            let _guard = AutoSyncSuppressionGuard::new();
+            assert!(is_auto_sync_suppressed());
+        }
+        assert!(!is_auto_sync_suppressed());
+    }
+
+    #[test]
+    fn max_wait_caps_flush_latency_for_continuous_events() {
+        let started = Instant::now();
+        let later = started + Duration::from_millis(MAX_AUTO_SYNC_WAIT_MS + 1);
+        assert!(auto_sync_wait_duration(started, later).is_none());
+    }
+
+    #[tokio::test]
+    async fn enqueue_change_signal_drops_when_channel_is_full() {
+        let (tx, _rx) = channel::<String>(1);
+        assert!(enqueue_change_signal(&tx, "providers"));
+        assert!(!enqueue_change_signal(&tx, "providers"));
+    }
+
+    #[test]
+    fn should_run_auto_sync_requires_enabled_and_auto_sync_flag() {
+        assert!(!should_run_auto_sync(None));
+
+        let disabled = WebDavSyncSettings {
+            enabled: false,
+            auto_sync: true,
+            ..WebDavSyncSettings::default()
+        };
+        assert!(!should_run_auto_sync(Some(&disabled)));
+
+        let auto_sync_off = WebDavSyncSettings {
+            enabled: true,
+            auto_sync: false,
+            ..WebDavSyncSettings::default()
+        };
+        assert!(!should_run_auto_sync(Some(&auto_sync_off)));
+
+        let enabled = WebDavSyncSettings {
+            enabled: true,
+            auto_sync: true,
+            ..WebDavSyncSettings::default()
+        };
+        assert!(should_run_auto_sync(Some(&enabled)));
+    }
+
+    #[test]
+    fn service_layer_does_not_depend_on_commands_layer() {
+        let source = include_str!("webdav_auto_sync.rs");
+        let needle = ["crate", "commands", ""].join("::");
+        assert!(
+            !source.contains(&needle),
+            "services layer should not depend on commands layer"
+        );
+    }
+}

src-tauri/src/services/webdav_sync.rs

@@ -0,0 +1,704 @@
+//! WebDAV v2 sync protocol layer.
+//!
+//! Implements manifest-based synchronization on top of the HTTP transport
+//! primitives in [`super::webdav`]. Artifact set: `db.sql` + `skills.zip`.
+
+use std::collections::BTreeMap;
+use std::fs;
+use std::future::Future;
+use std::process::Command;
+use std::sync::OnceLock;
+
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sha2::{Digest, Sha256};
+use tempfile::tempdir;
+
+use crate::error::AppError;
+use crate::services::webdav::{
+    auth_from_credentials, build_remote_url, ensure_remote_directories, get_bytes, head_etag,
+    path_segments, put_bytes, test_connection, WebDavAuth,
+};
+use crate::settings::{update_webdav_sync_status, WebDavSyncSettings, WebDavSyncStatus};
+
+mod archive;
+use archive::{
+    backup_current_skills, restore_skills_from_backup, restore_skills_zip, zip_skills_ssot,
+};
+
+// ─── Protocol constants ──────────────────────────────────────
+
+const PROTOCOL_FORMAT: &str = "cc-switch-webdav-sync";
+const PROTOCOL_VERSION: u32 = 2;
+const REMOTE_DB_SQL: &str = "db.sql";
+const REMOTE_SKILLS_ZIP: &str = "skills.zip";
+const REMOTE_MANIFEST: &str = "manifest.json";
+const MAX_DEVICE_NAME_LEN: usize = 64;
+const MAX_MANIFEST_BYTES: usize = 1024 * 1024;
+pub(super) const MAX_SYNC_ARTIFACT_BYTES: u64 = 512 * 1024 * 1024;
+
+pub fn sync_mutex() -> &'static tokio::sync::Mutex<()> {
+    static LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
+}
+
+pub async fn run_with_sync_lock<T, Fut>(operation: Fut) -> Result<T, AppError>
+where
+    Fut: Future<Output = Result<T, AppError>>,
+{
+    let _guard = sync_mutex().lock().await;
+    operation.await
+}
+
+fn localized(key: &'static str, zh: impl Into<String>, en: impl Into<String>) -> AppError {
+    AppError::localized(key, zh, en)
+}
+
+fn io_context_localized(
+    _key: &'static str,
+    zh: impl Into<String>,
+    en: impl Into<String>,
+    source: std::io::Error,
+) -> AppError {
+    let zh_msg = zh.into();
+    let en_msg = en.into();
+    AppError::IoContext {
+        context: format!("{zh_msg} ({en_msg})"),
+        source,
+    }
+}
+
+// ─── Types ───────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct SyncManifest {
+    format: String,
+    version: u32,
+    device_name: String,
+    created_at: String,
+    artifacts: BTreeMap<String, ArtifactMeta>,
+    snapshot_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ArtifactMeta {
+    sha256: String,
+    size: u64,
+}
+
+struct LocalSnapshot {
+    db_sql: Vec<u8>,
+    skills_zip: Vec<u8>,
+    manifest_bytes: Vec<u8>,
+    manifest_hash: String,
+}
+
+// ─── Public API ──────────────────────────────────────────────
+
+/// Check WebDAV connectivity and ensure remote directory structure.
+pub async fn check_connection(settings: &WebDavSyncSettings) -> Result<(), AppError> {
+    settings.validate()?;
+    let auth = auth_for(settings);
+    test_connection(&settings.base_url, &auth).await?;
+    let dir_segs = remote_dir_segments(settings);
+    ensure_remote_directories(&settings.base_url, &dir_segs, &auth).await?;
+    Ok(())
+}
+
+/// Upload local snapshot (db + skills) to remote.
+pub async fn upload(
+    db: &crate::database::Database,
+    settings: &mut WebDavSyncSettings,
+) -> Result<Value, AppError> {
+    settings.validate()?;
+    let auth = auth_for(settings);
+    let dir_segs = remote_dir_segments(settings);
+    ensure_remote_directories(&settings.base_url, &dir_segs, &auth).await?;
+
+    let snapshot = build_local_snapshot(db, settings)?;
+
+    // Upload order: artifacts first, manifest last (best-effort consistency)
+    let db_url = remote_file_url(settings, REMOTE_DB_SQL)?;
+    put_bytes(&db_url, &auth, snapshot.db_sql, "application/sql").await?;
+
+    let skills_url = remote_file_url(settings, REMOTE_SKILLS_ZIP)?;
+    put_bytes(&skills_url, &auth, snapshot.skills_zip, "application/zip").await?;
+
+    let manifest_url = remote_file_url(settings, REMOTE_MANIFEST)?;
+    put_bytes(
+        &manifest_url,
+        &auth,
+        snapshot.manifest_bytes,
+        "application/json",
+    )
+    .await?;
+
+    // Fetch etag (best-effort, don't fail the upload)
+    let etag = match head_etag(&manifest_url, &auth).await {
+        Ok(e) => e,
+        Err(e) => {
+            log::debug!("[WebDAV] Failed to fetch ETag after upload: {e}");
+            None
+        }
+    };
+
+    let _persisted = persist_sync_success_best_effort(
+        settings,
+        snapshot.manifest_hash,
+        etag,
+        persist_sync_success,
+    );
+    Ok(serde_json::json!({ "status": "uploaded" }))
+}
+
+/// Download remote snapshot and apply to local database + skills.
+pub async fn download(
+    db: &crate::database::Database,
+    settings: &mut WebDavSyncSettings,
+) -> Result<Value, AppError> {
+    settings.validate()?;
+    let auth = auth_for(settings);
+
+    let manifest_url = remote_file_url(settings, REMOTE_MANIFEST)?;
+    let (manifest_bytes, etag) = get_bytes(&manifest_url, &auth, MAX_MANIFEST_BYTES)
+        .await?
+        .ok_or_else(|| {
+            localized(
+                "webdav.sync.remote_empty",
+                "远端没有可下载的同步数据",
+                "No downloadable sync data found on the remote.",
+            )
+        })?;
+
+    let manifest: SyncManifest =
+        serde_json::from_slice(&manifest_bytes).map_err(|e| AppError::Json {
+            path: REMOTE_MANIFEST.to_string(),
+            source: e,
+        })?;
+
+    validate_manifest_compat(&manifest)?;
+
+    // Download and verify artifacts
+    let db_sql = download_and_verify(settings, &auth, REMOTE_DB_SQL, &manifest.artifacts).await?;
+    let skills_zip =
+        download_and_verify(settings, &auth, REMOTE_SKILLS_ZIP, &manifest.artifacts).await?;
+
+    // Apply snapshot
+    apply_snapshot(db, &db_sql, &skills_zip)?;
+
+    let manifest_hash = sha256_hex(&manifest_bytes);
+    let _persisted =
+        persist_sync_success_best_effort(settings, manifest_hash, etag, persist_sync_success);
+    Ok(serde_json::json!({ "status": "downloaded" }))
+}
+
+/// Fetch remote manifest info without downloading artifacts.
+pub async fn fetch_remote_info(settings: &WebDavSyncSettings) -> Result<Option<Value>, AppError> {
+    settings.validate()?;
+    let auth = auth_for(settings);
+    let manifest_url = remote_file_url(settings, REMOTE_MANIFEST)?;
+
+    let Some((bytes, _)) = get_bytes(&manifest_url, &auth, MAX_MANIFEST_BYTES).await? else {
+        return Ok(None);
+    };
+
+    let manifest: SyncManifest = serde_json::from_slice(&bytes).map_err(|e| AppError::Json {
+        path: REMOTE_MANIFEST.to_string(),
+        source: e,
+    })?;
+
+    let compatible = validate_manifest_compat(&manifest).is_ok();
+
+    let payload = serde_json::json!({
+        "deviceName": manifest.device_name,
+        "createdAt": manifest.created_at,
+        "snapshotId": manifest.snapshot_id,
+        "version": manifest.version,
+        "compatible": compatible,
+        "artifacts": manifest.artifacts.keys().collect::<Vec<_>>(),
+    });
+
+    Ok(Some(payload))
+}
+
+// ─── Sync status persistence (I3: deduplicated) ─────────────
+
+fn persist_sync_success(
+    settings: &mut WebDavSyncSettings,
+    manifest_hash: String,
+    etag: Option<String>,
+) -> Result<(), AppError> {
+    let status = WebDavSyncStatus {
+        last_sync_at: Some(Utc::now().timestamp()),
+        last_error: None,
+        last_error_source: None,
+        last_local_manifest_hash: Some(manifest_hash.clone()),
+        last_remote_manifest_hash: Some(manifest_hash),
+        last_remote_etag: etag,
+    };
+    settings.status = status.clone();
+    update_webdav_sync_status(status)
+}
+
+fn persist_sync_success_best_effort<F>(
+    settings: &mut WebDavSyncSettings,
+    manifest_hash: String,
+    etag: Option<String>,
+    persist_fn: F,
+) -> bool
+where
+    F: FnOnce(&mut WebDavSyncSettings, String, Option<String>) -> Result<(), AppError>,
+{
+    match persist_fn(settings, manifest_hash, etag) {
+        Ok(()) => true,
+        Err(err) => {
+            log::warn!("[WebDAV] Persist sync status failed, keep operation success: {err}");
+            false
+        }
+    }
+}
+
+// ─── Snapshot building ───────────────────────────────────────
+
+fn build_local_snapshot(
+    db: &crate::database::Database,
+    _settings: &WebDavSyncSettings,
+) -> Result<LocalSnapshot, AppError> {
+    // Export database to SQL string
+    let sql_string = db.export_sql_string()?;
+    let db_sql = sql_string.into_bytes();
+
+    // Pack skills into deterministic ZIP
+    let tmp = tempdir().map_err(|e| {
+        io_context_localized(
+            "webdav.sync.snapshot_tmpdir_failed",
+            "创建 WebDAV 快照临时目录失败",
+            "Failed to create temporary directory for WebDAV snapshot",
+            e,
+        )
+    })?;
+    let skills_zip_path = tmp.path().join(REMOTE_SKILLS_ZIP);
+    zip_skills_ssot(&skills_zip_path)?;
+    let skills_zip = fs::read(&skills_zip_path).map_err(|e| AppError::io(&skills_zip_path, e))?;
+
+    // Build artifact map and compute hashes
+    let mut artifacts = BTreeMap::new();
+    artifacts.insert(
+        REMOTE_DB_SQL.to_string(),
+        ArtifactMeta {
+            sha256: sha256_hex(&db_sql),
+            size: db_sql.len() as u64,
+        },
+    );
+    artifacts.insert(
+        REMOTE_SKILLS_ZIP.to_string(),
+        ArtifactMeta {
+            sha256: sha256_hex(&skills_zip),
+            size: skills_zip.len() as u64,
+        },
+    );
+
+    let snapshot_id = compute_snapshot_id(&artifacts);
+    let manifest = SyncManifest {
+        format: PROTOCOL_FORMAT.to_string(),
+        version: PROTOCOL_VERSION,
+        device_name: detect_system_device_name().unwrap_or_else(|| "Unknown Device".to_string()),
+        created_at: Utc::now().to_rfc3339(),
+        artifacts,
+        snapshot_id,
+    };
+    let manifest_bytes =
+        serde_json::to_vec_pretty(&manifest).map_err(|e| AppError::JsonSerialize { source: e })?;
+    let manifest_hash = sha256_hex(&manifest_bytes);
+
+    Ok(LocalSnapshot {
+        db_sql,
+        skills_zip,
+        manifest_bytes,
+        manifest_hash,
+    })
+}
+
+/// Compute a deterministic snapshot identity from artifact hashes.
+///
+/// BTreeMap iteration order is sorted by key, ensuring stability.
+fn compute_snapshot_id(artifacts: &BTreeMap<String, ArtifactMeta>) -> String {
+    let parts: Vec<String> = artifacts
+        .iter()
+        .map(|(name, meta)| format!("{}:{}", name, meta.sha256))
+        .collect();
+    sha256_hex(parts.join("|").as_bytes())
+}
+
+fn sha256_hex(bytes: &[u8]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(bytes);
+    format!("{:x}", hasher.finalize())
+}
+
+fn detect_system_device_name() -> Option<String> {
+    let env_name = ["CC_SWITCH_DEVICE_NAME", "COMPUTERNAME", "HOSTNAME"]
+        .iter()
+        .filter_map(|key| std::env::var(key).ok())
+        .find_map(|value| normalize_device_name(&value));
+
+    if env_name.is_some() {
+        return env_name;
+    }
+
+    let output = Command::new("hostname").output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let hostname = String::from_utf8(output.stdout).ok()?;
+    normalize_device_name(&hostname)
+}
+
+fn normalize_device_name(raw: &str) -> Option<String> {
+    let compact = raw
+        .chars()
+        .fold(String::with_capacity(raw.len()), |mut acc, ch| {
+            if ch.is_whitespace() {
+                acc.push(' ');
+            } else if !ch.is_control() {
+                acc.push(ch);
+            }
+            acc
+        });
+    let normalized = compact.split_whitespace().collect::<Vec<_>>().join(" ");
+    let trimmed = normalized.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+
+    let limited = trimmed
+        .chars()
+        .take(MAX_DEVICE_NAME_LEN)
+        .collect::<String>();
+    if limited.is_empty() {
+        None
+    } else {
+        Some(limited)
+    }
+}
+
+fn validate_manifest_compat(manifest: &SyncManifest) -> Result<(), AppError> {
+    if manifest.format != PROTOCOL_FORMAT {
+        return Err(localized(
+            "webdav.sync.manifest_format_incompatible",
+            format!("远端 manifest 格式不兼容: {}", manifest.format),
+            format!(
+                "Remote manifest format is incompatible: {}",
+                manifest.format
+            ),
+        ));
+    }
+    if manifest.version != PROTOCOL_VERSION {
+        return Err(localized(
+            "webdav.sync.manifest_version_incompatible",
+            format!(
+                "远端 manifest 协议版本不兼容: v{} (本地 v{PROTOCOL_VERSION})",
+                manifest.version
+            ),
+            format!(
+                "Remote manifest protocol version is incompatible: v{} (local v{PROTOCOL_VERSION})",
+                manifest.version
+            ),
+        ));
+    }
+    Ok(())
+}
+
+// ─── Download & verify ───────────────────────────────────────
+
+async fn download_and_verify(
+    settings: &WebDavSyncSettings,
+    auth: &WebDavAuth,
+    artifact_name: &str,
+    artifacts: &BTreeMap<String, ArtifactMeta>,
+) -> Result<Vec<u8>, AppError> {
+    let meta = artifacts.get(artifact_name).ok_or_else(|| {
+        localized(
+            "webdav.sync.manifest_missing_artifact",
+            format!("manifest 中缺少 artifact: {artifact_name}"),
+            format!("Manifest missing artifact: {artifact_name}"),
+        )
+    })?;
+    validate_artifact_size_limit(artifact_name, meta.size)?;
+
+    let url = remote_file_url(settings, artifact_name)?;
+    let (bytes, _) = get_bytes(&url, auth, MAX_SYNC_ARTIFACT_BYTES as usize)
+        .await?
+        .ok_or_else(|| {
+            localized(
+                "webdav.sync.remote_missing_artifact",
+                format!("远端缺少 artifact 文件: {artifact_name}"),
+                format!("Remote artifact file missing: {artifact_name}"),
+            )
+        })?;
+
+    // Quick size check before expensive hash
+    if bytes.len() as u64 != meta.size {
+        return Err(localized(
+            "webdav.sync.artifact_size_mismatch",
+            format!(
+                "artifact {artifact_name} 大小不匹配 (expected: {}, got: {})",
+                meta.size,
+                bytes.len(),
+            ),
+            format!(
+                "Artifact {artifact_name} size mismatch (expected: {}, got: {})",
+                meta.size,
+                bytes.len(),
+            ),
+        ));
+    }
+
+    let actual_hash = sha256_hex(&bytes);
+    if actual_hash != meta.sha256 {
+        return Err(localized(
+            "webdav.sync.artifact_hash_mismatch",
+            format!(
+                "artifact {artifact_name} SHA256 校验失败 (expected: {}..., got: {}...)",
+                meta.sha256.get(..8).unwrap_or(&meta.sha256),
+                actual_hash.get(..8).unwrap_or(&actual_hash),
+            ),
+            format!(
+                "Artifact {artifact_name} SHA256 verification failed (expected: {}..., got: {}...)",
+                meta.sha256.get(..8).unwrap_or(&meta.sha256),
+                actual_hash.get(..8).unwrap_or(&actual_hash),
+            ),
+        ));
+    }
+    Ok(bytes)
+}
+
+fn apply_snapshot(
+    db: &crate::database::Database,
+    db_sql: &[u8],
+    skills_zip: &[u8],
+) -> Result<(), AppError> {
+    let sql_str = std::str::from_utf8(db_sql).map_err(|e| {
+        localized(
+            "webdav.sync.sql_not_utf8",
+            format!("SQL 非 UTF-8: {e}"),
+            format!("SQL is not valid UTF-8: {e}"),
+        )
+    })?;
+    let skills_backup = backup_current_skills()?;
+
+    // 先替换 skills，再导入数据库；若导入失败则回滚 skills，避免“半恢复”。
+    restore_skills_zip(skills_zip)?;
+
+    if let Err(db_err) = db.import_sql_string(sql_str) {
+        if let Err(rollback_err) = restore_skills_from_backup(&skills_backup) {
+            return Err(localized(
+                "webdav.sync.db_import_and_rollback_failed",
+                format!("导入数据库失败: {db_err}; 同时回滚 Skills 失败: {rollback_err}"),
+                format!(
+                    "Database import failed: {db_err}; skills rollback also failed: {rollback_err}"
+                ),
+            ));
+        }
+        return Err(db_err);
+    }
+
+    Ok(())
+}
+
+// ─── Remote path helpers ─────────────────────────────────────
+
+fn remote_dir_segments(settings: &WebDavSyncSettings) -> Vec<String> {
+    let mut segs = Vec::new();
+    segs.extend(path_segments(&settings.remote_root).map(str::to_string));
+    segs.push(format!("v{PROTOCOL_VERSION}"));
+    segs.extend(path_segments(&settings.profile).map(str::to_string));
+    segs
+}
+
+fn remote_file_url(settings: &WebDavSyncSettings, file_name: &str) -> Result<String, AppError> {
+    let mut segs = remote_dir_segments(settings);
+    segs.extend(path_segments(file_name).map(str::to_string));
+    build_remote_url(&settings.base_url, &segs)
+}
+
+fn auth_for(settings: &WebDavSyncSettings) -> WebDavAuth {
+    auth_from_credentials(&settings.username, &settings.password)
+}
+
+fn validate_artifact_size_limit(artifact_name: &str, size: u64) -> Result<(), AppError> {
+    if size > MAX_SYNC_ARTIFACT_BYTES {
+        let max_mb = MAX_SYNC_ARTIFACT_BYTES / 1024 / 1024;
+        return Err(localized(
+            "webdav.sync.artifact_too_large",
+            format!("artifact {artifact_name} 超过下载上限（{} MB）", max_mb),
+            format!(
+                "Artifact {artifact_name} exceeds download limit ({} MB)",
+                max_mb
+            ),
+        ));
+    }
+    Ok(())
+}
+
+// ─── Tests ───────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn artifact(sha256: &str, size: u64) -> ArtifactMeta {
+        ArtifactMeta {
+            sha256: sha256.to_string(),
+            size,
+        }
+    }
+
+    #[test]
+    fn snapshot_id_is_stable() {
+        let mut artifacts = BTreeMap::new();
+        artifacts.insert("db.sql".to_string(), artifact("abc123", 100));
+        artifacts.insert("skills.zip".to_string(), artifact("def456", 200));
+
+        let id1 = compute_snapshot_id(&artifacts);
+        let id2 = compute_snapshot_id(&artifacts);
+        assert_eq!(id1, id2);
+    }
+
+    #[test]
+    fn snapshot_id_changes_with_artifacts() {
+        let mut a1 = BTreeMap::new();
+        a1.insert("db.sql".to_string(), artifact("hash-a", 1));
+
+        let mut a2 = BTreeMap::new();
+        a2.insert("db.sql".to_string(), artifact("hash-b", 1));
+
+        assert_ne!(compute_snapshot_id(&a1), compute_snapshot_id(&a2));
+    }
+
+    #[test]
+    fn remote_dir_segments_uses_v2() {
+        let settings = WebDavSyncSettings {
+            remote_root: "cc-switch-sync".to_string(),
+            profile: "default".to_string(),
+            ..WebDavSyncSettings::default()
+        };
+        let segs = remote_dir_segments(&settings);
+        assert_eq!(segs, vec!["cc-switch-sync", "v2", "default"]);
+    }
+
+    #[test]
+    fn sha256_hex_is_correct() {
+        let hash = sha256_hex(b"hello");
+        assert_eq!(
+            hash,
+            "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
+        );
+    }
+
+    #[test]
+    fn persist_best_effort_returns_true_on_success() {
+        let mut settings = WebDavSyncSettings::default();
+        let ok = persist_sync_success_best_effort(
+            &mut settings,
+            "hash".to_string(),
+            Some("etag".to_string()),
+            |_settings, _hash, _etag| Ok(()),
+        );
+        assert!(ok);
+    }
+
+    #[test]
+    fn persist_best_effort_returns_false_on_error() {
+        let mut settings = WebDavSyncSettings::default();
+        let ok = persist_sync_success_best_effort(
+            &mut settings,
+            "hash".to_string(),
+            None,
+            |_settings, _hash, _etag| Err(AppError::Config("boom".to_string())),
+        );
+        assert!(!ok);
+    }
+
+    fn manifest_with(format: &str, version: u32) -> SyncManifest {
+        let mut artifacts = BTreeMap::new();
+        artifacts.insert("db.sql".to_string(), artifact("abc", 1));
+        artifacts.insert("skills.zip".to_string(), artifact("def", 2));
+        SyncManifest {
+            format: format.to_string(),
+            version,
+            device_name: "My MacBook".to_string(),
+            created_at: "2026-02-12T00:00:00Z".to_string(),
+            artifacts,
+            snapshot_id: "snap-1".to_string(),
+        }
+    }
+
+    #[test]
+    fn validate_manifest_compat_accepts_supported_manifest() {
+        let manifest = manifest_with(PROTOCOL_FORMAT, PROTOCOL_VERSION);
+        assert!(validate_manifest_compat(&manifest).is_ok());
+    }
+
+    #[test]
+    fn validate_manifest_compat_rejects_wrong_format() {
+        let manifest = manifest_with("other-format", PROTOCOL_VERSION);
+        assert!(validate_manifest_compat(&manifest).is_err());
+    }
+
+    #[test]
+    fn validate_manifest_compat_rejects_wrong_version() {
+        let manifest = manifest_with(PROTOCOL_FORMAT, PROTOCOL_VERSION + 1);
+        assert!(validate_manifest_compat(&manifest).is_err());
+    }
+
+    #[test]
+    fn normalize_device_name_returns_none_for_blank_input() {
+        assert_eq!(normalize_device_name("   \n\t  "), None);
+    }
+
+    #[test]
+    fn normalize_device_name_collapses_whitespace_and_drops_control_chars() {
+        assert_eq!(
+            normalize_device_name("  Mac\tBook \n Pro\u{0007} "),
+            Some("Mac Book Pro".to_string())
+        );
+    }
+
+    #[test]
+    fn normalize_device_name_truncates_to_max_len() {
+        let long = "a".repeat(80);
+        assert_eq!(normalize_device_name(&long).map(|s| s.len()), Some(64));
+    }
+
+    #[test]
+    fn manifest_serialization_uses_device_name_only() {
+        let manifest = manifest_with(PROTOCOL_FORMAT, PROTOCOL_VERSION);
+        let value = serde_json::to_value(&manifest).expect("serialize manifest");
+        assert!(
+            value.get("deviceName").is_some(),
+            "manifest should contain deviceName"
+        );
+        assert!(
+            value.get("deviceId").is_none(),
+            "manifest should not contain deviceId"
+        );
+    }
+
+    #[test]
+    fn validate_artifact_size_limit_rejects_oversized_artifacts() {
+        let err = validate_artifact_size_limit("skills.zip", MAX_SYNC_ARTIFACT_BYTES + 1)
+            .expect_err("artifact larger than limit should be rejected");
+        assert!(
+            err.to_string().contains("too large") || err.to_string().contains("超过"),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn validate_artifact_size_limit_accepts_limit_boundary() {
+        assert!(validate_artifact_size_limit("skills.zip", MAX_SYNC_ARTIFACT_BYTES).is_ok());
+    }
+}

src-tauri/src/services/webdav_sync/archive.rs

@@ -0,0 +1,410 @@
+use std::collections::HashSet;
+use std::fs;
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+
+use tempfile::{tempdir, TempDir};
+use zip::write::SimpleFileOptions;
+use zip::DateTime;
+
+use crate::error::AppError;
+use crate::services::skill::SkillService;
+
+use super::{io_context_localized, localized, MAX_SYNC_ARTIFACT_BYTES, REMOTE_SKILLS_ZIP};
+
+/// Maximum number of entries allowed in a zip archive.
+const MAX_EXTRACT_ENTRIES: usize = 10_000;
+
+pub(super) struct SkillsBackup {
+    _tmp: TempDir,
+    backup_dir: PathBuf,
+    ssot_path: PathBuf,
+    existed: bool,
+}
+
+pub(super) fn zip_skills_ssot(dest_path: &Path) -> Result<(), AppError> {
+    let source = SkillService::get_ssot_dir().map_err(|e| {
+        localized(
+            "webdav.sync.skills_ssot_dir_failed",
+            format!("获取 Skills SSOT 目录失败: {e}"),
+            format!("Failed to resolve Skills SSOT directory: {e}"),
+        )
+    })?;
+    if let Some(parent) = dest_path.parent() {
+        fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
+    }
+
+    let file = fs::File::create(dest_path).map_err(|e| AppError::io(dest_path, e))?;
+    let mut writer = zip::ZipWriter::new(file);
+    let options = SimpleFileOptions::default()
+        .compression_method(zip::CompressionMethod::Deflated)
+        .last_modified_time(DateTime::default());
+
+    if source.exists() {
+        let canonical_root = fs::canonicalize(&source).unwrap_or_else(|_| source.clone());
+        let mut visited = HashSet::new();
+        mark_visited_dir(&canonical_root, &mut visited)?;
+        zip_dir_recursive(
+            &canonical_root,
+            &canonical_root,
+            &mut writer,
+            options,
+            &mut visited,
+        )?;
+    }
+
+    writer.finish().map_err(|e| {
+        localized(
+            "webdav.sync.skills_zip_write_failed",
+            format!("写入 skills.zip 失败: {e}"),
+            format!("Failed to write skills.zip: {e}"),
+        )
+    })?;
+    Ok(())
+}
+
+pub(super) fn restore_skills_zip(raw: &[u8]) -> Result<(), AppError> {
+    let tmp = tempdir().map_err(|e| {
+        io_context_localized(
+            "webdav.sync.skills_extract_tmpdir_failed",
+            "创建 skills 解压临时目录失败",
+            "Failed to create temporary directory for skills extraction",
+            e,
+        )
+    })?;
+    let zip_path = tmp.path().join(REMOTE_SKILLS_ZIP);
+    fs::write(&zip_path, raw).map_err(|e| AppError::io(&zip_path, e))?;
+
+    let file = fs::File::open(&zip_path).map_err(|e| AppError::io(&zip_path, e))?;
+    let mut archive = zip::ZipArchive::new(file).map_err(|e| {
+        localized(
+            "webdav.sync.skills_zip_parse_failed",
+            format!("解析 skills.zip 失败: {e}"),
+            format!("Failed to parse skills.zip: {e}"),
+        )
+    })?;
+
+    let extracted = tmp.path().join("skills-extracted");
+    fs::create_dir_all(&extracted).map_err(|e| AppError::io(&extracted, e))?;
+
+    if archive.len() > MAX_EXTRACT_ENTRIES {
+        return Err(localized(
+            "webdav.sync.skills_zip_too_many_entries",
+            format!(
+                "skills.zip 条目数过多（{}），上限 {MAX_EXTRACT_ENTRIES}",
+                archive.len()
+            ),
+            format!(
+                "skills.zip has too many entries ({}), limit is {MAX_EXTRACT_ENTRIES}",
+                archive.len()
+            ),
+        ));
+    }
+
+    let mut total_bytes: u64 = 0;
+    for idx in 0..archive.len() {
+        let mut entry = archive.by_index(idx).map_err(|e| {
+            localized(
+                "webdav.sync.skills_zip_entry_read_failed",
+                format!("读取 ZIP 项失败: {e}"),
+                format!("Failed to read ZIP entry: {e}"),
+            )
+        })?;
+        let Some(safe_name) = entry.enclosed_name() else {
+            continue;
+        };
+        let out_path = extracted.join(safe_name);
+        if entry.is_dir() {
+            fs::create_dir_all(&out_path).map_err(|e| AppError::io(&out_path, e))?;
+            continue;
+        }
+        if let Some(parent) = out_path.parent() {
+            fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
+        }
+        let mut out = fs::File::create(&out_path).map_err(|e| AppError::io(&out_path, e))?;
+        let _written = copy_entry_with_total_limit(
+            &mut entry,
+            &mut out,
+            &mut total_bytes,
+            MAX_SYNC_ARTIFACT_BYTES,
+            &out_path,
+        )?;
+    }
+
+    let ssot = SkillService::get_ssot_dir().map_err(|e| {
+        localized(
+            "webdav.sync.skills_ssot_dir_failed",
+            format!("获取 Skills SSOT 目录失败: {e}"),
+            format!("Failed to resolve Skills SSOT directory: {e}"),
+        )
+    })?;
+    let bak = ssot.with_extension("bak");
+
+    if ssot.exists() {
+        if bak.exists() {
+            let _ = fs::remove_dir_all(&bak);
+        }
+        fs::rename(&ssot, &bak).map_err(|e| AppError::io(&ssot, e))?;
+    }
+
+    if let Err(e) = copy_dir_recursive(&extracted, &ssot) {
+        if bak.exists() {
+            let _ = fs::remove_dir_all(&ssot);
+            let _ = fs::rename(&bak, &ssot);
+        }
+        return Err(e);
+    }
+
+    let _ = fs::remove_dir_all(&bak);
+    Ok(())
+}
+
+pub(super) fn backup_current_skills() -> Result<SkillsBackup, AppError> {
+    let ssot = SkillService::get_ssot_dir().map_err(|e| {
+        localized(
+            "webdav.sync.skills_ssot_dir_failed",
+            format!("获取 Skills SSOT 目录失败: {e}"),
+            format!("Failed to resolve Skills SSOT directory: {e}"),
+        )
+    })?;
+    let tmp = tempdir().map_err(|e| {
+        io_context_localized(
+            "webdav.sync.skills_backup_tmpdir_failed",
+            "创建 skills 备份临时目录失败",
+            "Failed to create temporary directory for skills backup",
+            e,
+        )
+    })?;
+    let backup_dir = tmp.path().join("skills-backup");
+
+    let existed = ssot.exists();
+    if existed {
+        copy_dir_recursive(&ssot, &backup_dir)?;
+    }
+
+    Ok(SkillsBackup {
+        _tmp: tmp,
+        backup_dir,
+        ssot_path: ssot,
+        existed,
+    })
+}
+
+pub(super) fn restore_skills_from_backup(backup: &SkillsBackup) -> Result<(), AppError> {
+    if backup.ssot_path.exists() {
+        fs::remove_dir_all(&backup.ssot_path).map_err(|e| AppError::io(&backup.ssot_path, e))?;
+    }
+
+    if backup.existed {
+        copy_dir_recursive(&backup.backup_dir, &backup.ssot_path)?;
+    }
+
+    Ok(())
+}
+
+fn zip_dir_recursive(
+    root: &Path,
+    current: &Path,
+    writer: &mut zip::ZipWriter<fs::File>,
+    options: SimpleFileOptions,
+    visited: &mut HashSet<PathBuf>,
+) -> Result<(), AppError> {
+    let mut entries: Vec<_> = fs::read_dir(current)
+        .map_err(|e| AppError::io(current, e))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| AppError::io(current, e))?;
+    entries.sort_by_key(|e| e.file_name());
+
+    for entry in entries {
+        let path = entry.path();
+        let name = entry.file_name();
+        let name_str = name.to_string_lossy();
+
+        if name_str.starts_with('.') {
+            continue;
+        }
+
+        let real_path = match fs::canonicalize(&path) {
+            Ok(p) if p.starts_with(root) => p,
+            Ok(_) => {
+                log::warn!(
+                    "[WebDAV] Skipping symlink outside skills root: {}",
+                    path.display()
+                );
+                continue;
+            }
+            Err(_) => path.clone(),
+        };
+
+        let rel = real_path
+            .strip_prefix(root)
+            .or_else(|_| path.strip_prefix(root))
+            .map_err(|e| {
+                localized(
+                    "webdav.sync.zip_relative_path_failed",
+                    format!("生成 ZIP 相对路径失败: {e}"),
+                    format!("Failed to build relative ZIP path: {e}"),
+                )
+            })?;
+        let rel_str = rel.to_string_lossy().replace('\\', "/");
+
+        if real_path.is_dir() {
+            if !mark_visited_dir(&real_path, visited)? {
+                log::warn!(
+                    "[WebDAV] Skipping already visited directory: {}",
+                    real_path.display()
+                );
+                continue;
+            }
+            writer
+                .add_directory(format!("{rel_str}/"), options)
+                .map_err(|e| {
+                    localized(
+                        "webdav.sync.zip_add_directory_failed",
+                        format!("写入 ZIP 目录失败: {e}"),
+                        format!("Failed to write ZIP directory entry: {e}"),
+                    )
+                })?;
+            zip_dir_recursive(root, &real_path, writer, options, visited)?;
+        } else {
+            writer.start_file(&rel_str, options).map_err(|e| {
+                localized(
+                    "webdav.sync.zip_start_file_failed",
+                    format!("写入 ZIP 文件头失败: {e}"),
+                    format!("Failed to start ZIP file entry: {e}"),
+                )
+            })?;
+            let mut file = fs::File::open(&real_path).map_err(|e| AppError::io(&real_path, e))?;
+            let mut buf = Vec::new();
+            file.read_to_end(&mut buf)
+                .map_err(|e| AppError::io(&real_path, e))?;
+            writer.write_all(&buf).map_err(|e| {
+                localized(
+                    "webdav.sync.zip_write_file_failed",
+                    format!("写入 ZIP 文件内容失败: {e}"),
+                    format!("Failed to write ZIP file content: {e}"),
+                )
+            })?;
+        }
+    }
+    Ok(())
+}
+
+fn copy_dir_recursive(src: &Path, dest: &Path) -> Result<(), AppError> {
+    let mut visited = HashSet::new();
+    copy_dir_recursive_inner(src, dest, &mut visited)
+}
+
+fn copy_dir_recursive_inner(
+    src: &Path,
+    dest: &Path,
+    visited: &mut HashSet<PathBuf>,
+) -> Result<(), AppError> {
+    if !src.exists() {
+        return Ok(());
+    }
+    if !mark_visited_dir(src, visited)? {
+        log::warn!(
+            "[WebDAV] Skipping already visited copy path: {}",
+            src.display()
+        );
+        return Ok(());
+    }
+    fs::create_dir_all(dest).map_err(|e| AppError::io(dest, e))?;
+    for entry in fs::read_dir(src).map_err(|e| AppError::io(src, e))? {
+        let entry = entry.map_err(|e| AppError::io(src, e))?;
+        let path = entry.path();
+        let dest_path = dest.join(entry.file_name());
+        if path.is_dir() {
+            copy_dir_recursive_inner(&path, &dest_path, visited)?;
+        } else {
+            fs::copy(&path, &dest_path).map_err(|e| AppError::io(&dest_path, e))?;
+        }
+    }
+    Ok(())
+}
+
+fn mark_visited_dir(path: &Path, visited: &mut HashSet<PathBuf>) -> Result<bool, AppError> {
+    let canonical = fs::canonicalize(path).map_err(|e| AppError::io(path, e))?;
+    Ok(visited.insert(canonical))
+}
+
+fn copy_entry_with_total_limit<R: Read, W: Write>(
+    reader: &mut R,
+    writer: &mut W,
+    total_bytes: &mut u64,
+    max_total_bytes: u64,
+    out_path: &Path,
+) -> Result<u64, AppError> {
+    let mut buffer = [0u8; 16 * 1024];
+    let mut written = 0u64;
+    loop {
+        let n = reader
+            .read(&mut buffer)
+            .map_err(|e| AppError::io(out_path, e))?;
+        if n == 0 {
+            break;
+        }
+
+        if total_bytes.saturating_add(n as u64) > max_total_bytes {
+            let max_mb = max_total_bytes / 1024 / 1024;
+            return Err(localized(
+                "webdav.sync.skills_zip_too_large",
+                format!("skills.zip 解压后体积超过上限（{} MB）", max_mb),
+                format!("skills.zip extracted size exceeds limit ({} MB)", max_mb),
+            ));
+        }
+
+        writer
+            .write_all(&buffer[..n])
+            .map_err(|e| AppError::io(out_path, e))?;
+        *total_bytes += n as u64;
+        written += n as u64;
+    }
+    Ok(written)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{copy_entry_with_total_limit, mark_visited_dir};
+    use std::collections::HashSet;
+    use std::io::Cursor;
+    use std::path::Path;
+    use tempfile::tempdir;
+
+    #[test]
+    fn mark_visited_dir_tracks_canonical_duplicates() {
+        let temp = tempdir().expect("tempdir");
+        let dir = temp.path().join("skills");
+        std::fs::create_dir_all(&dir).expect("create dir");
+
+        let mut visited = HashSet::new();
+        assert!(mark_visited_dir(&dir, &mut visited).expect("first visit"));
+        assert!(!mark_visited_dir(&dir, &mut visited).expect("second visit"));
+    }
+
+    #[test]
+    fn copy_entry_with_total_limit_rejects_oversized_stream_before_write() {
+        let mut reader = Cursor::new(vec![1u8; 16]);
+        let mut writer = Vec::new();
+        let mut total_bytes = 0u64;
+
+        let err = copy_entry_with_total_limit(
+            &mut reader,
+            &mut writer,
+            &mut total_bytes,
+            8,
+            Path::new("skills-extracted/file.bin"),
+        )
+        .expect_err("stream larger than limit should be rejected");
+        assert!(
+            err.to_string().contains("too large") || err.to_string().contains("超过"),
+            "unexpected error: {err}"
+        );
+        assert_eq!(
+            writer.len(),
+            0,
+            "should not write when the first chunk exceeds limit"
+        );
+    }
+}

src-tauri/src/session_manager/mod.rs

@@ -4,7 +4,7 @@ pub mod terminal;
 use serde::Serialize;
 use std::path::Path;
 
-use providers::{claude, codex};
+use providers::{claude, codex, gemini, openclaw, opencode};
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -37,9 +37,27 @@ pub struct SessionMessage {
 }
 
 pub fn scan_sessions() -> Vec<SessionMeta> {
+    let (r1, r2, r3, r4, r5) = std::thread::scope(|s| {
+        let h1 = s.spawn(codex::scan_sessions);
+        let h2 = s.spawn(claude::scan_sessions);
+        let h3 = s.spawn(opencode::scan_sessions);
+        let h4 = s.spawn(openclaw::scan_sessions);
+        let h5 = s.spawn(gemini::scan_sessions);
+        (
+            h1.join().unwrap_or_default(),
+            h2.join().unwrap_or_default(),
+            h3.join().unwrap_or_default(),
+            h4.join().unwrap_or_default(),
+            h5.join().unwrap_or_default(),
+        )
+    });
+
     let mut sessions = Vec::new();
-    sessions.extend(codex::scan_sessions());
-    sessions.extend(claude::scan_sessions());
+    sessions.extend(r1);
+    sessions.extend(r2);
+    sessions.extend(r3);
+    sessions.extend(r4);
+    sessions.extend(r5);
 
     sessions.sort_by(|a, b| {
         let a_ts = a.last_active_at.or(a.created_at).unwrap_or(0);
@@ -55,6 +73,9 @@ pub fn load_messages(provider_id: &str, source_path: &str) -> Result<Vec<Session
     match provider_id {
         "codex" => codex::load_messages(path),
         "claude" => claude::load_messages(path),
+        "opencode" => opencode::load_messages(path),
+        "openclaw" => openclaw::load_messages(path),
+        "gemini" => gemini::load_messages(path),
         _ => Err(format!("Unsupported provider: {provider_id}")),
     }
 }

src-tauri/src/session_manager/providers/claude.rs

@@ -7,7 +7,9 @@ use serde_json::Value;
 use crate::config::get_claude_config_dir;
 use crate::session_manager::{SessionMessage, SessionMeta};
 
-use super::utils::{extract_text, parse_timestamp_to_ms, path_basename, truncate_summary};
+use super::utils::{
+    extract_text, parse_timestamp_to_ms, path_basename, read_head_tail_lines, truncate_summary,
+};
 
 const PROVIDER_ID: &str = "claude";
 
@@ -73,60 +75,61 @@ fn parse_session(path: &Path) -> Option<SessionMeta> {
         return None;
     }
 
-    let file = File::open(path).ok()?;
-    let reader = BufReader::new(file);
+    let (head, tail) = read_head_tail_lines(path, 10, 30).ok()?;
 
     let mut session_id: Option<String> = None;
     let mut project_dir: Option<String> = None;
     let mut created_at: Option<i64> = None;
-    let mut last_active_at: Option<i64> = None;
-    let mut summary: Option<String> = None;
 
-    for line in reader.lines() {
-        let line = match line {
-            Ok(value) => value,
-            Err(_) => continue,
-        };
-        let value: Value = match serde_json::from_str(&line) {
+    // Extract metadata from head lines
+    for line in &head {
+        let value: Value = match serde_json::from_str(line) {
             Ok(parsed) => parsed,
             Err(_) => continue,
         };
-
         if session_id.is_none() {
             session_id = value
                 .get("sessionId")
                 .and_then(Value::as_str)
                 .map(|s| s.to_string());
         }
-
         if project_dir.is_none() {
             project_dir = value
                 .get("cwd")
                 .and_then(Value::as_str)
                 .map(|s| s.to_string());
         }
-
-        if let Some(ts) = value.get("timestamp").and_then(parse_timestamp_to_ms) {
-            if created_at.is_none() {
-                created_at = Some(ts);
-            }
-            last_active_at = Some(ts);
+        if created_at.is_none() {
+            created_at = value.get("timestamp").and_then(parse_timestamp_to_ms);
         }
+    }
 
-        if value.get("isMeta").and_then(Value::as_bool) == Some(true) {
-            continue;
-        }
+    // Extract last_active_at and summary from tail lines (reverse order)
+    let mut last_active_at: Option<i64> = None;
+    let mut summary: Option<String> = None;
 
-        let message = match value.get("message") {
-            Some(message) => message,
-            None => continue,
+    for line in tail.iter().rev() {
+        let value: Value = match serde_json::from_str(line) {
+            Ok(parsed) => parsed,
+            Err(_) => continue,
         };
-
-        let text = message.get("content").map(extract_text).unwrap_or_default();
-        if text.trim().is_empty() {
-            continue;
+        if last_active_at.is_none() {
+            last_active_at = value.get("timestamp").and_then(parse_timestamp_to_ms);
+        }
+        if summary.is_none() {
+            if value.get("isMeta").and_then(Value::as_bool) == Some(true) {
+                continue;
+            }
+            if let Some(message) = value.get("message") {
+                let text = message.get("content").map(extract_text).unwrap_or_default();
+                if !text.trim().is_empty() {
+                    summary = Some(text);
+                }
+            }
+        }
+        if last_active_at.is_some() && summary.is_some() {
+            break;
         }
-        summary = Some(text);
     }
 
     let session_id = session_id.or_else(|| infer_session_id_from_filename(path));

src-tauri/src/session_manager/providers/codex.rs

@@ -1,6 +1,7 @@
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
 
 use regex::Regex;
 use serde_json::Value;
@@ -8,10 +9,17 @@ use serde_json::Value;
 use crate::codex_config::get_codex_config_dir;
 use crate::session_manager::{SessionMessage, SessionMeta};
 
-use super::utils::{extract_text, parse_timestamp_to_ms, path_basename, truncate_summary};
+use super::utils::{
+    extract_text, parse_timestamp_to_ms, path_basename, read_head_tail_lines, truncate_summary,
+};
 
 const PROVIDER_ID: &str = "codex";
 
+static UUID_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
+        .unwrap()
+});
+
 pub fn scan_sessions() -> Vec<SessionMeta> {
     let root = get_codex_config_dir().join("sessions");
     let mut files = Vec::new();
@@ -74,32 +82,21 @@ pub fn load_messages(path: &Path) -> Result<Vec<SessionMessage>, String> {
 }
 
 fn parse_session(path: &Path) -> Option<SessionMeta> {
-    let file = File::open(path).ok()?;
-    let reader = BufReader::new(file);
+    let (head, tail) = read_head_tail_lines(path, 10, 30).ok()?;
 
     let mut session_id: Option<String> = None;
     let mut project_dir: Option<String> = None;
     let mut created_at: Option<i64> = None;
-    let mut last_active_at: Option<i64> = None;
-    let mut summary: Option<String> = None;
 
-    for line in reader.lines() {
-        let line = match line {
-            Ok(value) => value,
-            Err(_) => continue,
-        };
-        let value: Value = match serde_json::from_str(&line) {
+    // Extract metadata from head lines
+    for line in &head {
+        let value: Value = match serde_json::from_str(line) {
             Ok(parsed) => parsed,
             Err(_) => continue,
         };
-
-        if let Some(ts) = value.get("timestamp").and_then(parse_timestamp_to_ms) {
-            if created_at.is_none() {
-                created_at = Some(ts);
-            }
-            last_active_at = Some(ts);
+        if created_at.is_none() {
+            created_at = value.get("timestamp").and_then(parse_timestamp_to_ms);
         }
-
         if value.get("type").and_then(Value::as_str) == Some("session_meta") {
             if let Some(payload) = value.get("payload") {
                 if session_id.is_none() {
@@ -118,27 +115,34 @@ fn parse_session(path: &Path) -> Option<SessionMeta> {
                     created_at.get_or_insert(ts);
                 }
             }
-            continue;
         }
+    }
 
-        if value.get("type").and_then(Value::as_str) != Some("response_item") {
-            continue;
-        }
+    // Extract last_active_at and summary from tail lines (reverse order)
+    let mut last_active_at: Option<i64> = None;
+    let mut summary: Option<String> = None;
 
-        let payload = match value.get("payload") {
-            Some(payload) => payload,
-            None => continue,
+    for line in tail.iter().rev() {
+        let value: Value = match serde_json::from_str(line) {
+            Ok(parsed) => parsed,
+            Err(_) => continue,
         };
-
-        if payload.get("type").and_then(Value::as_str) != Some("message") {
-            continue;
+        if last_active_at.is_none() {
+            last_active_at = value.get("timestamp").and_then(parse_timestamp_to_ms);
         }
-
-        let text = payload.get("content").map(extract_text).unwrap_or_default();
-        if text.trim().is_empty() {
-            continue;
+        if summary.is_none() && value.get("type").and_then(Value::as_str) == Some("response_item") {
+            if let Some(payload) = value.get("payload") {
+                if payload.get("type").and_then(Value::as_str) == Some("message") {
+                    let text = payload.get("content").map(extract_text).unwrap_or_default();
+                    if !text.trim().is_empty() {
+                        summary = Some(text);
+                    }
+                }
+            }
+        }
+        if last_active_at.is_some() && summary.is_some() {
+            break;
         }
-        summary = Some(text);
     }
 
     let session_id = session_id.or_else(|| infer_session_id_from_filename(path));
@@ -166,10 +170,7 @@ fn parse_session(path: &Path) -> Option<SessionMeta> {
 
 fn infer_session_id_from_filename(path: &Path) -> Option<String> {
     let file_name = path.file_name()?.to_string_lossy();
-    let re =
-        Regex::new(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
-            .ok()?;
-    re.find(&file_name).map(|mat| mat.as_str().to_string())
+    UUID_RE.find(&file_name).map(|mat| mat.as_str().to_string())
 }
 
 fn collect_jsonl_files(root: &Path, files: &mut Vec<PathBuf>) {

src-tauri/src/session_manager/providers/gemini.rs

@@ -0,0 +1,117 @@
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::session_manager::{SessionMessage, SessionMeta};
+
+use super::utils::{parse_timestamp_to_ms, truncate_summary};
+
+const PROVIDER_ID: &str = "gemini";
+
+pub fn scan_sessions() -> Vec<SessionMeta> {
+    let gemini_dir = crate::gemini_config::get_gemini_dir();
+    let tmp_dir = gemini_dir.join("tmp");
+    if !tmp_dir.exists() {
+        return Vec::new();
+    }
+
+    let mut sessions = Vec::new();
+
+    // Iterate over project hash directories: tmp/<project_hash>/chats/session-*.json
+    let project_dirs = match std::fs::read_dir(&tmp_dir) {
+        Ok(entries) => entries,
+        Err(_) => return Vec::new(),
+    };
+
+    for entry in project_dirs.flatten() {
+        let chats_dir = entry.path().join("chats");
+        if !chats_dir.is_dir() {
+            continue;
+        }
+
+        let chat_files = match std::fs::read_dir(&chats_dir) {
+            Ok(entries) => entries,
+            Err(_) => continue,
+        };
+
+        for file_entry in chat_files.flatten() {
+            let path = file_entry.path();
+            if path.extension().and_then(|e| e.to_str()) != Some("json") {
+                continue;
+            }
+            if let Some(meta) = parse_session(&path) {
+                sessions.push(meta);
+            }
+        }
+    }
+
+    sessions
+}
+
+pub fn load_messages(path: &Path) -> Result<Vec<SessionMessage>, String> {
+    let data = std::fs::read_to_string(path).map_err(|e| format!("Failed to read session: {e}"))?;
+    let value: Value =
+        serde_json::from_str(&data).map_err(|e| format!("Failed to parse session JSON: {e}"))?;
+
+    let messages = value
+        .get("messages")
+        .and_then(Value::as_array)
+        .ok_or_else(|| "No messages array found".to_string())?;
+
+    let mut result = Vec::new();
+    for msg in messages {
+        let content = match msg.get("content").and_then(Value::as_str) {
+            Some(c) if !c.trim().is_empty() => c.to_string(),
+            _ => continue,
+        };
+
+        let role = match msg.get("type").and_then(Value::as_str) {
+            Some("gemini") => "assistant".to_string(),
+            Some("user") => "user".to_string(),
+            Some(other) => other.to_string(),
+            None => continue,
+        };
+
+        let ts = msg.get("timestamp").and_then(parse_timestamp_to_ms);
+
+        result.push(SessionMessage { role, content, ts });
+    }
+
+    Ok(result)
+}
+
+fn parse_session(path: &Path) -> Option<SessionMeta> {
+    let data = std::fs::read_to_string(path).ok()?;
+    let value: Value = serde_json::from_str(&data).ok()?;
+
+    let session_id = value.get("sessionId").and_then(Value::as_str)?.to_string();
+
+    let created_at = value.get("startTime").and_then(parse_timestamp_to_ms);
+    let last_active_at = value.get("lastUpdated").and_then(parse_timestamp_to_ms);
+
+    // Derive title from first user message
+    let title = value
+        .get("messages")
+        .and_then(Value::as_array)
+        .and_then(|msgs| {
+            msgs.iter()
+                .find(|m| m.get("type").and_then(Value::as_str) == Some("user"))
+                .and_then(|m| m.get("content").and_then(Value::as_str))
+                .filter(|s| !s.trim().is_empty())
+                .map(|s| truncate_summary(s, 160))
+        });
+
+    let source_path = path.to_string_lossy().to_string();
+
+    Some(SessionMeta {
+        provider_id: PROVIDER_ID.to_string(),
+        session_id: session_id.clone(),
+        title: title.clone(),
+        summary: title,
+        project_dir: None, // project hash is not reversible
+        created_at,
+        last_active_at: last_active_at.or(created_at),
+        source_path: Some(source_path),
+        resume_command: Some(format!("gemini --resume {session_id}")),
+    })
+}

src-tauri/src/session_manager/providers/mod.rs

@@ -1,3 +1,6 @@
 pub mod claude;
 pub mod codex;
+pub mod gemini;
+pub mod openclaw;
+pub mod opencode;
 mod utils;

src-tauri/src/session_manager/providers/openclaw.rs

@@ -0,0 +1,208 @@
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::path::Path;
+
+use serde_json::Value;
+
+use crate::openclaw_config::get_openclaw_dir;
+use crate::session_manager::{SessionMessage, SessionMeta};
+
+use super::utils::{
+    extract_text, parse_timestamp_to_ms, path_basename, read_head_tail_lines, truncate_summary,
+};
+
+const PROVIDER_ID: &str = "openclaw";
+
+pub fn scan_sessions() -> Vec<SessionMeta> {
+    let agents_dir = get_openclaw_dir().join("agents");
+    if !agents_dir.exists() {
+        return Vec::new();
+    }
+
+    let mut sessions = Vec::new();
+
+    // Traverse each agent directory
+    let agent_entries = match std::fs::read_dir(&agents_dir) {
+        Ok(entries) => entries,
+        Err(_) => return sessions,
+    };
+
+    for agent_entry in agent_entries.flatten() {
+        let agent_path = agent_entry.path();
+        if !agent_path.is_dir() {
+            continue;
+        }
+
+        let sessions_dir = agent_path.join("sessions");
+        if !sessions_dir.is_dir() {
+            continue;
+        }
+
+        let session_entries = match std::fs::read_dir(&sessions_dir) {
+            Ok(entries) => entries,
+            Err(_) => continue,
+        };
+
+        for entry in session_entries.flatten() {
+            let path = entry.path();
+            if path.extension().and_then(|ext| ext.to_str()) != Some("jsonl") {
+                continue;
+            }
+            // Skip sessions.json index file
+            if path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .map(|n| n == "sessions.json")
+                .unwrap_or(false)
+            {
+                continue;
+            }
+
+            if let Some(meta) = parse_session(&path) {
+                sessions.push(meta);
+            }
+        }
+    }
+
+    sessions
+}
+
+pub fn load_messages(path: &Path) -> Result<Vec<SessionMessage>, String> {
+    let file = File::open(path).map_err(|e| format!("Failed to open session file: {e}"))?;
+    let reader = BufReader::new(file);
+    let mut messages = Vec::new();
+
+    for line in reader.lines() {
+        let line = match line {
+            Ok(value) => value,
+            Err(_) => continue,
+        };
+        let value: Value = match serde_json::from_str(&line) {
+            Ok(parsed) => parsed,
+            Err(_) => continue,
+        };
+
+        if value.get("type").and_then(Value::as_str) != Some("message") {
+            continue;
+        }
+
+        let message = match value.get("message") {
+            Some(msg) => msg,
+            None => continue,
+        };
+
+        let raw_role = message
+            .get("role")
+            .and_then(Value::as_str)
+            .unwrap_or("unknown");
+
+        // Map OpenClaw roles to our standard roles
+        let role = match raw_role {
+            "toolResult" => "tool".to_string(),
+            other => other.to_string(),
+        };
+
+        let content = message.get("content").map(extract_text).unwrap_or_default();
+        if content.trim().is_empty() {
+            continue;
+        }
+
+        let ts = value.get("timestamp").and_then(parse_timestamp_to_ms);
+
+        messages.push(SessionMessage { role, content, ts });
+    }
+
+    Ok(messages)
+}
+
+fn parse_session(path: &Path) -> Option<SessionMeta> {
+    let (head, tail) = read_head_tail_lines(path, 10, 30).ok()?;
+
+    let mut session_id: Option<String> = None;
+    let mut cwd: Option<String> = None;
+    let mut created_at: Option<i64> = None;
+    let mut summary: Option<String> = None;
+
+    // Extract metadata and first message summary from head lines
+    for line in &head {
+        let value: Value = match serde_json::from_str(line) {
+            Ok(parsed) => parsed,
+            Err(_) => continue,
+        };
+
+        if created_at.is_none() {
+            created_at = value.get("timestamp").and_then(parse_timestamp_to_ms);
+        }
+
+        let event_type = value.get("type").and_then(Value::as_str).unwrap_or("");
+
+        if event_type == "session" {
+            if session_id.is_none() {
+                session_id = value
+                    .get("id")
+                    .and_then(Value::as_str)
+                    .map(|s| s.to_string());
+            }
+            if cwd.is_none() {
+                cwd = value
+                    .get("cwd")
+                    .and_then(Value::as_str)
+                    .map(|s| s.to_string());
+            }
+            if let Some(ts) = value.get("timestamp").and_then(parse_timestamp_to_ms) {
+                created_at.get_or_insert(ts);
+            }
+            continue;
+        }
+
+        // OpenClaw summary is the first message content
+        if event_type == "message" && summary.is_none() {
+            if let Some(message) = value.get("message") {
+                let text = message.get("content").map(extract_text).unwrap_or_default();
+                if !text.trim().is_empty() {
+                    summary = Some(text);
+                }
+            }
+        }
+    }
+
+    // Extract last_active_at from tail lines (reverse order)
+    let mut last_active_at: Option<i64> = None;
+    for line in tail.iter().rev() {
+        let value: Value = match serde_json::from_str(line) {
+            Ok(parsed) => parsed,
+            Err(_) => continue,
+        };
+        if let Some(ts) = value.get("timestamp").and_then(parse_timestamp_to_ms) {
+            last_active_at = Some(ts);
+            break;
+        }
+    }
+
+    // Fall back to filename as session ID
+    let session_id = session_id.or_else(|| {
+        path.file_stem()
+            .and_then(|s| s.to_str())
+            .map(|s| s.to_string())
+    });
+    let session_id = session_id?;
+
+    let title = cwd
+        .as_deref()
+        .and_then(path_basename)
+        .map(|s| s.to_string());
+
+    let summary = summary.map(|text| truncate_summary(&text, 160));
+
+    Some(SessionMeta {
+        provider_id: PROVIDER_ID.to_string(),
+        session_id: session_id.clone(),
+        title,
+        summary,
+        project_dir: cwd,
+        created_at,
+        last_active_at,
+        source_path: Some(path.to_string_lossy().to_string()),
+        resume_command: None, // OpenClaw sessions are gateway-managed, no CLI resume
+    })
+}

src-tauri/src/session_manager/providers/opencode.rs

@@ -0,0 +1,276 @@
+use std::path::{Path, PathBuf};
+
+use serde_json::Value;
+
+use crate::session_manager::{SessionMessage, SessionMeta};
+
+use super::utils::{parse_timestamp_to_ms, path_basename, truncate_summary};
+
+const PROVIDER_ID: &str = "opencode";
+
+/// Return the OpenCode data directory.
+///
+/// Respects `XDG_DATA_HOME` on all platforms; falls back to
+/// `~/.local/share/opencode/storage/`.
+fn get_opencode_data_dir() -> PathBuf {
+    if let Ok(xdg) = std::env::var("XDG_DATA_HOME") {
+        if !xdg.is_empty() {
+            return PathBuf::from(xdg).join("opencode").join("storage");
+        }
+    }
+    dirs::home_dir()
+        .map(|h| h.join(".local/share/opencode/storage"))
+        .unwrap_or_else(|| PathBuf::from(".local/share/opencode/storage"))
+}
+
+pub fn scan_sessions() -> Vec<SessionMeta> {
+    let storage = get_opencode_data_dir();
+    let session_dir = storage.join("session");
+    if !session_dir.exists() {
+        return Vec::new();
+    }
+
+    let mut json_files = Vec::new();
+    collect_json_files(&session_dir, &mut json_files);
+
+    let mut sessions = Vec::new();
+    for path in json_files {
+        if let Some(meta) = parse_session(&storage, &path) {
+            sessions.push(meta);
+        }
+    }
+    sessions
+}
+
+pub fn load_messages(path: &Path) -> Result<Vec<SessionMessage>, String> {
+    // `path` is the message directory: storage/message/{sessionID}/
+    if !path.is_dir() {
+        return Err(format!("Message directory not found: {}", path.display()));
+    }
+
+    let storage = path
+        .parent()
+        .and_then(|p| p.parent())
+        .ok_or_else(|| "Cannot determine storage root from message path".to_string())?;
+
+    let mut msg_files = Vec::new();
+    collect_json_files(path, &mut msg_files);
+
+    // Parse all messages and collect (created_ts, message_id, role, parts_text)
+    let mut entries: Vec<(i64, String, String, String)> = Vec::new();
+
+    for msg_path in &msg_files {
+        let data = match std::fs::read_to_string(msg_path) {
+            Ok(d) => d,
+            Err(_) => continue,
+        };
+        let value: Value = match serde_json::from_str(&data) {
+            Ok(v) => v,
+            Err(_) => continue,
+        };
+
+        let msg_id = match value.get("id").and_then(Value::as_str) {
+            Some(id) => id.to_string(),
+            None => continue,
+        };
+
+        let role = value
+            .get("role")
+            .and_then(Value::as_str)
+            .unwrap_or("unknown")
+            .to_string();
+
+        let created_ts = value
+            .get("time")
+            .and_then(|t| t.get("created"))
+            .and_then(parse_timestamp_to_ms)
+            .unwrap_or(0);
+
+        // Collect text parts from storage/part/{messageID}/
+        let part_dir = storage.join("part").join(&msg_id);
+        let text = collect_parts_text(&part_dir);
+        if text.trim().is_empty() {
+            continue;
+        }
+
+        entries.push((created_ts, msg_id, role, text));
+    }
+
+    // Sort by created timestamp
+    entries.sort_by_key(|(ts, _, _, _)| *ts);
+
+    let messages = entries
+        .into_iter()
+        .map(|(ts, _, role, content)| SessionMessage {
+            role,
+            content,
+            ts: if ts > 0 { Some(ts) } else { None },
+        })
+        .collect();
+
+    Ok(messages)
+}
+
+fn parse_session(storage: &Path, path: &Path) -> Option<SessionMeta> {
+    let data = std::fs::read_to_string(path).ok()?;
+    let value: Value = serde_json::from_str(&data).ok()?;
+
+    let session_id = value.get("id").and_then(Value::as_str)?.to_string();
+    let title = value
+        .get("title")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+    let directory = value
+        .get("directory")
+        .and_then(Value::as_str)
+        .map(|s| s.to_string());
+
+    let created_at = value
+        .get("time")
+        .and_then(|t| t.get("created"))
+        .and_then(parse_timestamp_to_ms);
+    let updated_at = value
+        .get("time")
+        .and_then(|t| t.get("updated"))
+        .and_then(parse_timestamp_to_ms);
+
+    // Derive title from directory basename if no explicit title
+    let has_title = title.is_some();
+    let display_title = title.or_else(|| {
+        directory
+            .as_deref()
+            .and_then(path_basename)
+            .map(|s| s.to_string())
+    });
+
+    // Build source_path = message directory for this session
+    let msg_dir = storage.join("message").join(&session_id);
+    let source_path = msg_dir.to_string_lossy().to_string();
+
+    // Skip expensive I/O if title already available from session JSON
+    let summary = if has_title {
+        display_title.clone()
+    } else {
+        get_first_user_summary(storage, &session_id)
+    };
+
+    Some(SessionMeta {
+        provider_id: PROVIDER_ID.to_string(),
+        session_id: session_id.clone(),
+        title: display_title,
+        summary,
+        project_dir: directory,
+        created_at,
+        last_active_at: updated_at.or(created_at),
+        source_path: Some(source_path),
+        resume_command: Some(format!("opencode session resume {session_id}")),
+    })
+}
+
+/// Read the first user message's first text part to use as summary.
+fn get_first_user_summary(storage: &Path, session_id: &str) -> Option<String> {
+    let msg_dir = storage.join("message").join(session_id);
+    if !msg_dir.is_dir() {
+        return None;
+    }
+
+    let mut msg_files = Vec::new();
+    collect_json_files(&msg_dir, &mut msg_files);
+
+    // Collect user messages with timestamps for ordering
+    let mut user_msgs: Vec<(i64, String)> = Vec::new();
+    for msg_path in &msg_files {
+        let data = match std::fs::read_to_string(msg_path) {
+            Ok(d) => d,
+            Err(_) => continue,
+        };
+        let value: Value = match serde_json::from_str(&data) {
+            Ok(v) => v,
+            Err(_) => continue,
+        };
+
+        if value.get("role").and_then(Value::as_str) != Some("user") {
+            continue;
+        }
+
+        let msg_id = match value.get("id").and_then(Value::as_str) {
+            Some(id) => id.to_string(),
+            None => continue,
+        };
+
+        let ts = value
+            .get("time")
+            .and_then(|t| t.get("created"))
+            .and_then(parse_timestamp_to_ms)
+            .unwrap_or(0);
+
+        user_msgs.push((ts, msg_id));
+    }
+
+    user_msgs.sort_by_key(|(ts, _)| *ts);
+
+    // Take first user message and get its parts
+    let (_, first_id) = user_msgs.first()?;
+    let part_dir = storage.join("part").join(first_id);
+    let text = collect_parts_text(&part_dir);
+    if text.trim().is_empty() {
+        return None;
+    }
+    Some(truncate_summary(&text, 160))
+}
+
+/// Collect text content from all parts in a part directory.
+fn collect_parts_text(part_dir: &Path) -> String {
+    if !part_dir.is_dir() {
+        return String::new();
+    }
+
+    let mut parts = Vec::new();
+    collect_json_files(part_dir, &mut parts);
+
+    let mut texts = Vec::new();
+    for part_path in &parts {
+        let data = match std::fs::read_to_string(part_path) {
+            Ok(d) => d,
+            Err(_) => continue,
+        };
+        let value: Value = match serde_json::from_str(&data) {
+            Ok(v) => v,
+            Err(_) => continue,
+        };
+
+        // Only include text-type parts
+        if value.get("type").and_then(Value::as_str) != Some("text") {
+            continue;
+        }
+
+        if let Some(text) = value.get("text").and_then(Value::as_str) {
+            if !text.trim().is_empty() {
+                texts.push(text.to_string());
+            }
+        }
+    }
+
+    texts.join("\n")
+}
+
+fn collect_json_files(root: &Path, files: &mut Vec<PathBuf>) {
+    if !root.exists() {
+        return;
+    }
+
+    let entries = match std::fs::read_dir(root) {
+        Ok(entries) => entries,
+        Err(_) => return,
+    };
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            collect_json_files(&path, files);
+        } else if path.extension().and_then(|ext| ext.to_str()) == Some("json") {
+            files.push(path);
+        }
+    }
+}

src-tauri/src/session_manager/providers/utils.rs

@@ -1,6 +1,50 @@
+use std::fs::File;
+use std::io::{self, BufRead, BufReader, Seek, SeekFrom};
+use std::path::Path;
+
 use chrono::{DateTime, FixedOffset};
 use serde_json::Value;
 
+/// Read the first `head_n` lines and last `tail_n` lines from a file.
+/// For small files (< 16 KB), reads all lines once to avoid unnecessary seeking.
+pub fn read_head_tail_lines(
+    path: &Path,
+    head_n: usize,
+    tail_n: usize,
+) -> io::Result<(Vec<String>, Vec<String>)> {
+    let file = File::open(path)?;
+    let file_len = file.metadata()?.len();
+
+    // For small files, read all lines once and split
+    if file_len < 16_384 {
+        let reader = BufReader::new(file);
+        let all: Vec<String> = reader.lines().map_while(Result::ok).collect();
+        let head = all.iter().take(head_n).cloned().collect();
+        let skip = all.len().saturating_sub(tail_n);
+        let tail = all.into_iter().skip(skip).collect();
+        return Ok((head, tail));
+    }
+
+    // Read head lines from the beginning
+    let reader = BufReader::new(file);
+    let head: Vec<String> = reader.lines().take(head_n).map_while(Result::ok).collect();
+
+    // Seek to last ~16 KB for tail lines
+    let seek_pos = file_len.saturating_sub(16_384);
+    let mut file2 = File::open(path)?;
+    file2.seek(SeekFrom::Start(seek_pos))?;
+    let tail_reader = BufReader::new(file2);
+    let all_tail: Vec<String> = tail_reader.lines().map_while(Result::ok).collect();
+
+    // Skip first partial line if we seeked into the middle of a line
+    let skip_first = if seek_pos > 0 { 1 } else { 0 };
+    let usable: Vec<String> = all_tail.into_iter().skip(skip_first).collect();
+    let skip = usable.len().saturating_sub(tail_n);
+    let tail = usable.into_iter().skip(skip).collect();
+
+    Ok((head, tail))
+}
+
 pub fn parse_timestamp_to_ms(value: &Value) -> Option<i64> {
     let raw = value.as_str()?;
     DateTime::parse_from_rfc3339(raw)

src-tauri/src/settings.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::fs;
+use std::io::Write;
 use std::path::PathBuf;
 use std::sync::{OnceLock, RwLock};
 
@@ -33,6 +34,8 @@ pub struct VisibleApps {
     pub gemini: bool,
     #[serde(default = "default_true")]
     pub opencode: bool,
+    #[serde(default = "default_true")]
+    pub openclaw: bool,
 }
 
 impl Default for VisibleApps {
@@ -42,6 +45,7 @@ impl Default for VisibleApps {
             codex: true,
             gemini: true,
             opencode: true,
+            openclaw: true,
         }
     }
 }
@@ -54,10 +58,111 @@ impl VisibleApps {
             AppType::Codex => self.codex,
             AppType::Gemini => self.gemini,
             AppType::OpenCode => self.opencode,
+            AppType::OpenClaw => self.openclaw,
         }
     }
 }
 
+/// WebDAV 同步状态（持久化同步进度信息）
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavSyncStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_sync_at: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_error: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_error_source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_remote_etag: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_local_manifest_hash: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_remote_manifest_hash: Option<String>,
+}
+
+fn default_remote_root() -> String {
+    "cc-switch-sync".to_string()
+}
+fn default_profile() -> String {
+    "default".to_string()
+}
+
+/// WebDAV v2 同步设置
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavSyncSettings {
+    #[serde(default)]
+    pub enabled: bool,
+    #[serde(default)]
+    pub auto_sync: bool,
+    #[serde(default)]
+    pub base_url: String,
+    #[serde(default)]
+    pub username: String,
+    #[serde(default)]
+    pub password: String,
+    #[serde(default = "default_remote_root")]
+    pub remote_root: String,
+    #[serde(default = "default_profile")]
+    pub profile: String,
+    #[serde(default)]
+    pub status: WebDavSyncStatus,
+}
+
+impl Default for WebDavSyncSettings {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            auto_sync: false,
+            base_url: String::new(),
+            username: String::new(),
+            password: String::new(),
+            remote_root: default_remote_root(),
+            profile: default_profile(),
+            status: WebDavSyncStatus::default(),
+        }
+    }
+}
+
+impl WebDavSyncSettings {
+    pub fn validate(&self) -> Result<(), crate::error::AppError> {
+        if self.base_url.trim().is_empty() {
+            return Err(crate::error::AppError::localized(
+                "webdav.base_url.required",
+                "WebDAV 地址不能为空",
+                "WebDAV URL is required.",
+            ));
+        }
+        if self.username.trim().is_empty() {
+            return Err(crate::error::AppError::localized(
+                "webdav.username.required",
+                "WebDAV 用户名不能为空",
+                "WebDAV username is required.",
+            ));
+        }
+        Ok(())
+    }
+
+    pub fn normalize(&mut self) {
+        self.base_url = self.base_url.trim().to_string();
+        self.username = self.username.trim().to_string();
+        self.remote_root = self.remote_root.trim().to_string();
+        self.profile = self.profile.trim().to_string();
+        if self.remote_root.is_empty() {
+            self.remote_root = default_remote_root();
+        }
+        if self.profile.is_empty() {
+            self.profile = default_profile();
+        }
+    }
+
+    /// Returns true if all credential fields are blank (no config to persist).
+    fn is_empty(&self) -> bool {
+        self.base_url.is_empty() && self.username.is_empty() && self.password.is_empty()
+    }
+}
+
 /// 应用设置结构
 ///
 /// 存储设备级别设置，保存在本地 `~/.cc-switch/settings.json`，不随数据库同步。
@@ -82,6 +187,15 @@ pub struct AppSettings {
     /// 静默启动（程序启动时不显示主窗口，仅托盘运行）
     #[serde(default)]
     pub silent_startup: bool,
+    /// 是否在主页面启用本地代理功能（默认关闭）
+    #[serde(default)]
+    pub enable_local_proxy: bool,
+    /// User has confirmed the local proxy first-run notice
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub proxy_confirmed: Option<bool>,
+    /// User has confirmed the usage query first-run notice
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub usage_confirmed: Option<bool>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub language: Option<String>,
 
@@ -98,6 +212,8 @@ pub struct AppSettings {
     pub gemini_config_dir: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub opencode_config_dir: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub openclaw_config_dir: Option<String>,
 
     // ===== 当前供应商 ID（设备级）=====
     /// 当前 Claude 供应商 ID（本地存储，优先于数据库 is_current）
@@ -112,12 +228,31 @@ pub struct AppSettings {
     /// 当前 OpenCode 供应商 ID（本地存储，对 OpenCode 可能无意义，但保持结构一致）
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub current_provider_opencode: Option<String>,
+    /// 当前 OpenClaw 供应商 ID（本地存储，对 OpenClaw 可能无意义，但保持结构一致）
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub current_provider_openclaw: Option<String>,
 
     // ===== Skill 同步设置 =====
     /// Skill 同步方式：auto（默认，优先 symlink）、symlink、copy
     #[serde(default)]
     pub skill_sync_method: SyncMethod,
 
+    // ===== WebDAV 同步设置 =====
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub webdav_sync: Option<WebDavSyncSettings>,
+
+    // ===== WebDAV 备份设置（旧版，保留向后兼容）=====
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub webdav_backup: Option<serde_json::Value>,
+
+    // ===== 备份策略设置 =====
+    /// Auto-backup interval in hours (default 24, 0 = disabled)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub backup_interval_hours: Option<u32>,
+    /// Maximum number of backup files to retain (default 10)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub backup_retain_count: Option<u32>,
+
     // ===== 终端设置 =====
     /// 首选终端应用（可选，默认使用系统默认终端）
     /// - macOS: "terminal" | "iterm2" | "warp" | "alacritty" | "kitty" | "ghostty"
@@ -144,17 +279,26 @@ impl Default for AppSettings {
             skip_claude_onboarding: false,
             launch_on_startup: false,
             silent_startup: false,
+            enable_local_proxy: false,
+            proxy_confirmed: None,
+            usage_confirmed: None,
             language: None,
             visible_apps: None,
             claude_config_dir: None,
             codex_config_dir: None,
             gemini_config_dir: None,
             opencode_config_dir: None,
+            openclaw_config_dir: None,
             current_provider_claude: None,
             current_provider_codex: None,
             current_provider_gemini: None,
             current_provider_opencode: None,
+            current_provider_openclaw: None,
             skill_sync_method: SyncMethod::default(),
+            webdav_sync: None,
+            webdav_backup: None,
+            backup_interval_hours: None,
+            backup_retain_count: None,
             preferred_terminal: None,
         }
     }
@@ -199,12 +343,26 @@ impl AppSettings {
             .filter(|s| !s.is_empty())
             .map(|s| s.to_string());
 
+        self.openclaw_config_dir = self
+            .openclaw_config_dir
+            .as_ref()
+            .map(|s| s.trim())
+            .filter(|s| !s.is_empty())
+            .map(|s| s.to_string());
+
         self.language = self
             .language
             .as_ref()
             .map(|s| s.trim())
             .filter(|s| matches!(*s, "en" | "zh" | "ja"))
             .map(|s| s.to_string());
+
+        if let Some(sync) = &mut self.webdav_sync {
+            sync.normalize();
+            if sync.is_empty() {
+                self.webdav_sync = None;
+            }
+        }
     }
 
     fn load_from_file() -> Self {
@@ -245,7 +403,27 @@ fn save_settings_file(settings: &AppSettings) -> Result<(), AppError> {
 
     let json = serde_json::to_string_pretty(&normalized)
         .map_err(|e| AppError::JsonSerialize { source: e })?;
-    fs::write(&path, json).map_err(|e| AppError::io(&path, e))?;
+    #[cfg(unix)]
+    {
+        use std::fs::OpenOptions;
+        use std::os::unix::fs::OpenOptionsExt;
+
+        let mut file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .mode(0o600)
+            .open(&path)
+            .map_err(|e| AppError::io(&path, e))?;
+        file.write_all(json.as_bytes())
+            .map_err(|e| AppError::io(&path, e))?;
+    }
+
+    #[cfg(not(unix))]
+    {
+        fs::write(&path, json).map_err(|e| AppError::io(&path, e))?;
+    }
+
     Ok(())
 }
 
@@ -283,6 +461,15 @@ pub fn get_settings() -> AppSettings {
         .clone()
 }
 
+pub fn get_settings_for_frontend() -> AppSettings {
+    let mut settings = get_settings();
+    if let Some(sync) = &mut settings.webdav_sync {
+        sync.password.clear();
+    }
+    settings.webdav_backup = None;
+    settings
+}
+
 pub fn update_settings(mut new_settings: AppSettings) -> Result<(), AppError> {
     new_settings.normalize_paths();
     save_settings_file(&new_settings)?;
@@ -295,6 +482,22 @@ pub fn update_settings(mut new_settings: AppSettings) -> Result<(), AppError> {
     Ok(())
 }
 
+fn mutate_settings<F>(mutator: F) -> Result<(), AppError>
+where
+    F: FnOnce(&mut AppSettings),
+{
+    let mut guard = settings_store().write().unwrap_or_else(|e| {
+        log::warn!("设置锁已毒化，使用恢复值: {e}");
+        e.into_inner()
+    });
+    let mut next = guard.clone();
+    mutator(&mut next);
+    next.normalize_paths();
+    save_settings_file(&next)?;
+    *guard = next;
+    Ok(())
+}
+
 /// 从文件重新加载设置到内存缓存
 /// 用于导入配置等场景，确保内存缓存与文件同步
 pub fn reload_settings() -> Result<(), AppError> {
@@ -339,6 +542,14 @@ pub fn get_opencode_override_dir() -> Option<PathBuf> {
         .map(|p| resolve_override_path(p))
 }
 
+pub fn get_openclaw_override_dir() -> Option<PathBuf> {
+    let settings = settings_store().read().ok()?;
+    settings
+        .openclaw_config_dir
+        .as_ref()
+        .map(|p| resolve_override_path(p))
+}
+
 // ===== 当前供应商管理函数 =====
 
 /// 获取指定应用类型的当前供应商 ID（从本地 settings 读取）
@@ -352,6 +563,7 @@ pub fn get_current_provider(app_type: &AppType) -> Option<String> {
         AppType::Codex => settings.current_provider_codex.clone(),
         AppType::Gemini => settings.current_provider_gemini.clone(),
         AppType::OpenCode => settings.current_provider_opencode.clone(),
+        AppType::OpenClaw => settings.current_provider_openclaw.clone(),
     }
 }
 
@@ -367,6 +579,7 @@ pub fn set_current_provider(app_type: &AppType, id: Option<&str>) -> Result<(),
         AppType::Codex => settings.current_provider_codex = id.map(|s| s.to_string()),
         AppType::Gemini => settings.current_provider_gemini = id.map(|s| s.to_string()),
         AppType::OpenCode => settings.current_provider_opencode = id.map(|s| s.to_string()),
+        AppType::OpenClaw => settings.current_provider_openclaw = id.map(|s| s.to_string()),
     }
 
     update_settings(settings)
@@ -420,6 +633,33 @@ pub fn get_skill_sync_method() -> SyncMethod {
         .skill_sync_method
 }
 
+// ===== 备份策略管理函数 =====
+
+/// Get the effective auto-backup interval in hours (default 24)
+pub fn effective_backup_interval_hours() -> u32 {
+    settings_store()
+        .read()
+        .unwrap_or_else(|e| {
+            log::warn!("设置锁已毒化，使用恢复值: {e}");
+            e.into_inner()
+        })
+        .backup_interval_hours
+        .unwrap_or(24)
+}
+
+/// Get the effective backup retain count (default 10, minimum 1)
+pub fn effective_backup_retain_count() -> usize {
+    settings_store()
+        .read()
+        .unwrap_or_else(|e| {
+            log::warn!("设置锁已毒化，使用恢复值: {e}");
+            e.into_inner()
+        })
+        .backup_retain_count
+        .map(|n| (n as usize).max(1))
+        .unwrap_or(10)
+}
+
 // ===== 终端设置管理函数 =====
 
 /// 获取首选终端应用
@@ -433,3 +673,26 @@ pub fn get_preferred_terminal() -> Option<String> {
         .preferred_terminal
         .clone()
 }
+
+// ===== WebDAV 同步设置管理函数 =====
+
+/// 获取 WebDAV 同步设置
+pub fn get_webdav_sync_settings() -> Option<WebDavSyncSettings> {
+    settings_store().read().ok()?.webdav_sync.clone()
+}
+
+/// 保存 WebDAV 同步设置
+pub fn set_webdav_sync_settings(settings: Option<WebDavSyncSettings>) -> Result<(), AppError> {
+    mutate_settings(|current| {
+        current.webdav_sync = settings;
+    })
+}
+
+/// 仅更新 WebDAV 同步状态，避免覆写 credentials/root/profile 等字段
+pub fn update_webdav_sync_status(status: WebDavSyncStatus) -> Result<(), AppError> {
+    mutate_settings(|current| {
+        if let Some(sync) = current.webdav_sync.as_mut() {
+            sync.status = status;
+        }
+    })
+}

src-tauri/src/tray.rs

@@ -15,7 +15,7 @@ pub struct TrayTexts {
     pub show_main: &'static str,
     pub no_provider_hint: &'static str,
     pub quit: &'static str,
-    pub auto_label: &'static str,
+    pub _auto_label: &'static str,
 }
 
 impl TrayTexts {
@@ -25,20 +25,20 @@ impl TrayTexts {
                 show_main: "Open main window",
                 no_provider_hint: "  (No providers yet, please add them from the main window)",
                 quit: "Quit",
-                auto_label: "Auto (Failover)",
+                _auto_label: "Auto (Failover)",
             },
             "ja" => Self {
                 show_main: "メインウィンドウを開く",
                 no_provider_hint:
                     "  (プロバイダーがまだありません。メイン画面から追加してください)",
                 quit: "終了",
-                auto_label: "自動 (フェイルオーバー)",
+                _auto_label: "自動 (フェイルオーバー)",
             },
             _ => Self {
                 show_main: "打开主界面",
                 no_provider_hint: "  (无供应商，请在主界面添加)",
                 quit: "退出",
-                auto_label: "自动 (故障转移)",
+                _auto_label: "自动 (故障转移)",
             },
         }
     }
@@ -91,7 +91,7 @@ fn append_provider_section<'a>(
     manager: Option<&crate::provider::ProviderManager>,
     section: &TrayAppSection,
     tray_texts: &TrayTexts,
-    app_state: &AppState,
+    _app_state: &AppState,
 ) -> Result<MenuBuilder<'a, tauri::Wry, tauri::AppHandle<tauri::Wry>>, AppError> {
     let Some(manager) = manager else {
         return Ok(menu_builder);
@@ -119,22 +119,9 @@ fn append_provider_section<'a>(
         return Ok(menu_builder.item(&empty_hint));
     }
 
-    // 获取 proxy 状态，决定 Auto 是否选中
-    let (proxy_enabled, auto_failover) =
-        app_state.db.get_proxy_flags_sync(section.app_type.as_str());
-    let auto_mode = proxy_enabled && auto_failover;
-
-    // 添加 Auto 菜单项（始终显示在供应商列表前）
-    let auto_item = CheckMenuItem::with_id(
-        app,
-        format!("{}{}", section.prefix, AUTO_SUFFIX),
-        tray_texts.auto_label,
-        true,
-        auto_mode,
-        None::<&str>,
-    )
-    .map_err(|e| AppError::Message(format!("创建{}Auto菜单项失败: {e}", section.log_name)))?;
-    menu_builder = menu_builder.item(&auto_item);
+    // Auto (Failover) menu item is hidden from tray; the feature is still
+    // accessible from the Settings page.  Keep the surrounding code intact so
+    // it can be re-enabled easily in the future.
 
     let mut sorted_providers: Vec<_> = manager.providers.iter().collect();
     sorted_providers.sort_by(|(_, a), (_, b)| {
@@ -156,8 +143,7 @@ fn append_provider_section<'a>(
     });
 
     for (id, provider) in sorted_providers {
-        // Auto 模式下所有供应商都不选中
-        let is_current = !auto_mode && manager.current == *id;
+        let is_current = manager.current == *id;
         let item = CheckMenuItem::with_id(
             app,
             format!("{}{}", section.prefix, id),

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "CC Switch",
-  "version": "3.10.3",
+  "version": "3.11.1",
   "identifier": "com.ccswitch.desktop",
   "build": {
     "frontendDist": "../dist",

src/App.tsx

@@ -3,6 +3,7 @@ import { useTranslation } from "react-i18next";
 import { motion, AnimatePresence } from "framer-motion";
 import { toast } from "sonner";
 import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
 import { useQueryClient } from "@tanstack/react-query";
 import {
   Plus,
@@ -16,6 +17,10 @@ import {
   Download,
   FolderArchive,
   Search,
+  FolderOpen,
+  KeyRound,
+  Shield,
+  Cpu,
 } from "lucide-react";
 import type { Provider, VisibleApps } from "@/types";
 import type { EnvConflict } from "@/types/env";
@@ -28,7 +33,9 @@ import {
 } from "@/lib/api";
 import { checkAllEnvConflicts, checkEnvConflicts } from "@/lib/api/env";
 import { useProviderActions } from "@/hooks/useProviderActions";
+import { openclawKeys } from "@/hooks/useOpenClaw";
 import { useProxyStatus } from "@/hooks/useProxyStatus";
+import { useAutoCompact } from "@/hooks/useAutoCompact";
 import { useLastValidValue } from "@/hooks/useLastValidValue";
 import { extractErrorMessage } from "@/utils/errorUtils";
 import { isTextEditableTarget } from "@/utils/domUtils";
@@ -55,7 +62,14 @@ import { UniversalProviderPanel } from "@/components/universal";
 import { McpIcon } from "@/components/BrandIcons";
 import { Button } from "@/components/ui/button";
 import { SessionManagerPage } from "@/components/sessions/SessionManagerPage";
-import { useDisableCurrentOmo } from "@/lib/query/omo";
+import {
+  useDisableCurrentOmo,
+  useDisableCurrentOmoSlim,
+} from "@/lib/query/omo";
+import WorkspaceFilesPanel from "@/components/workspace/WorkspaceFilesPanel";
+import EnvPanel from "@/components/openclaw/EnvPanel";
+import ToolsPanel from "@/components/openclaw/ToolsPanel";
+import AgentsDefaultsPanel from "@/components/openclaw/AgentsDefaultsPanel";
 
 type View =
   | "providers"
@@ -66,14 +80,30 @@ type View =
   | "mcp"
   | "agents"
   | "universal"
-  | "sessions";
+  | "sessions"
+  | "workspace"
+  | "openclawEnv"
+  | "openclawTools"
+  | "openclawAgents";
+
+interface WebDavSyncStatusUpdatedPayload {
+  source?: string;
+  status?: string;
+  error?: string;
+}
 
 const DRAG_BAR_HEIGHT = isWindows() || isLinux() ? 0 : 28; // px
 const HEADER_HEIGHT = 64; // px
 const CONTENT_TOP_OFFSET = DRAG_BAR_HEIGHT + HEADER_HEIGHT;
 
 const STORAGE_KEY = "cc-switch-last-app";
-const VALID_APPS: AppId[] = ["claude", "codex", "gemini", "opencode"];
+const VALID_APPS: AppId[] = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+  "openclaw",
+];
 
 const getInitialApp = (): AppId => {
   const saved = localStorage.getItem(STORAGE_KEY) as AppId | null;
@@ -94,6 +124,10 @@ const VALID_VIEWS: View[] = [
   "agents",
   "universal",
   "sessions",
+  "workspace",
+  "openclawEnv",
+  "openclawTools",
+  "openclawAgents",
 ];
 
 const getInitialView = (): View => {
@@ -123,6 +157,7 @@ function App() {
     codex: true,
     gemini: true,
     opencode: true,
+    openclaw: true,
   };
 
   const getFirstVisibleApp = (): AppId => {
@@ -130,6 +165,7 @@ function App() {
     if (visibleApps.codex) return "codex";
     if (visibleApps.gemini) return "gemini";
     if (visibleApps.opencode) return "opencode";
+    if (visibleApps.openclaw) return "openclaw";
     return "claude"; // fallback
   };
 
@@ -144,7 +180,10 @@ function App() {
     if (
       currentView === "sessions" &&
       activeApp !== "claude" &&
-      activeApp !== "codex"
+      activeApp !== "codex" &&
+      activeApp !== "opencode" &&
+      activeApp !== "openclaw" &&
+      activeApp !== "gemini"
     ) {
       setCurrentView("providers");
     }
@@ -162,6 +201,9 @@ function App() {
   const effectiveEditingProvider = useLastValidValue(editingProvider);
   const effectiveUsageProvider = useLastValidValue(usageProvider);
 
+  const toolbarRef = useRef<HTMLDivElement>(null);
+  const isToolbarCompact = useAutoCompact(toolbarRef);
+
   const promptPanelRef = useRef<any>(null);
   const mcpPanelRef = useRef<any>(null);
   const skillsPageRef = useRef<any>(null);
@@ -188,7 +230,12 @@ function App() {
   const providers = useMemo(() => data?.providers ?? {}, [data]);
   const currentProviderId = data?.currentProviderId ?? "";
   const hasSkillsSupport = true;
-  const hasSessionSupport = activeApp === "claude" || activeApp === "codex";
+  const hasSessionSupport =
+    activeApp === "claude" ||
+    activeApp === "codex" ||
+    activeApp === "opencode" ||
+    activeApp === "openclaw" ||
+    activeApp === "gemini";
 
   const {
     addProvider,
@@ -196,6 +243,7 @@ function App() {
     switchProvider,
     deleteProvider,
     saveUsageScript,
+    setAsDefaultModel,
   } = useProviderActions(activeApp);
 
   const disableOmoMutation = useDisableCurrentOmo();
@@ -215,6 +263,23 @@ function App() {
     });
   };
 
+  const disableOmoSlimMutation = useDisableCurrentOmoSlim();
+  const handleDisableOmoSlim = () => {
+    disableOmoSlimMutation.mutate(undefined, {
+      onSuccess: () => {
+        toast.success(t("omo.disabled", { defaultValue: "OMO 已停用" }));
+      },
+      onError: (error: Error) => {
+        toast.error(
+          t("omo.disableFailed", {
+            defaultValue: "停用 OMO 失败: {{error}}",
+            error: extractErrorMessage(error),
+          }),
+        );
+      },
+    });
+  };
+
   useEffect(() => {
     let unsubscribe: (() => void) | undefined;
 
@@ -266,6 +331,50 @@ function App() {
     };
   }, [queryClient]);
 
+  useEffect(() => {
+    let unsubscribe: (() => void) | undefined;
+    let active = true;
+
+    const setupListener = async () => {
+      try {
+        const off = await listen(
+          "webdav-sync-status-updated",
+          async (event) => {
+            const payload = (event.payload ??
+              {}) as WebDavSyncStatusUpdatedPayload;
+            await queryClient.invalidateQueries({ queryKey: ["settings"] });
+
+            if (payload.source !== "auto" || payload.status !== "error") {
+              return;
+            }
+
+            toast.error(
+              t("settings.webdavSync.autoSyncFailedToast", {
+                error: payload.error || t("common.unknown"),
+              }),
+            );
+          },
+        );
+        if (!active) {
+          off();
+          return;
+        }
+        unsubscribe = off;
+      } catch (error) {
+        console.error(
+          "[App] Failed to subscribe webdav-sync-status-updated event",
+          error,
+        );
+      }
+    };
+
+    void setupListener();
+    return () => {
+      active = false;
+      unsubscribe?.();
+    };
+  }, [queryClient, t]);
+
   useEffect(() => {
     const checkEnvOnStartup = async () => {
       try {
@@ -423,10 +532,19 @@ function App() {
     const { provider, action } = confirmAction;
 
     if (action === "remove") {
+      // Remove from live config only (for additive mode apps like OpenCode/OpenClaw)
+      // Does NOT delete from database - provider remains in the list
       await providersApi.removeFromLiveConfig(provider.id, activeApp);
-      await queryClient.invalidateQueries({
-        queryKey: ["opencodeLiveProviderIds"],
-      });
+      // Invalidate queries to refresh the isInConfig state
+      if (activeApp === "opencode") {
+        await queryClient.invalidateQueries({
+          queryKey: ["opencodeLiveProviderIds"],
+        });
+      } else if (activeApp === "openclaw") {
+        await queryClient.invalidateQueries({
+          queryKey: openclawKeys.liveProviderIds,
+        });
+      }
       toast.success(
         t("notifications.removeFromConfigSuccess", {
           defaultValue: "已从配置移除",
@@ -586,7 +704,11 @@ function App() {
           return (
             <SkillsPage
               ref={skillsPageRef}
-              initialApp={activeApp === "opencode" ? "claude" : activeApp}
+              initialApp={
+                activeApp === "opencode" || activeApp === "openclaw"
+                  ? "claude"
+                  : activeApp
+              }
             />
           );
         case "mcp":
@@ -608,7 +730,15 @@ function App() {
           );
 
         case "sessions":
-          return <SessionManagerPage />;
+          return <SessionManagerPage key={activeApp} appId={activeApp} />;
+        case "workspace":
+          return <WorkspaceFilesPanel />;
+        case "openclawEnv":
+          return <EnvPanel />;
+        case "openclawTools":
+          return <ToolsPanel />;
+        case "openclawAgents":
+          return <AgentsDefaultsPanel />;
         default:
           return (
             <div className="px-6 flex flex-col h-[calc(100vh-8rem)] overflow-hidden">
@@ -640,7 +770,7 @@ function App() {
                         setConfirmAction({ provider, action: "delete" })
                       }
                       onRemoveFromConfig={
-                        activeApp === "opencode"
+                        activeApp === "opencode" || activeApp === "openclaw"
                           ? (provider) =>
                               setConfirmAction({ provider, action: "remove" })
                           : undefined
@@ -648,6 +778,11 @@ function App() {
                       onDisableOmo={
                         activeApp === "opencode" ? handleDisableOmo : undefined
                       }
+                      onDisableOmoSlim={
+                        activeApp === "opencode"
+                          ? handleDisableOmoSlim
+                          : undefined
+                      }
                       onDuplicate={handleDuplicateProvider}
                       onConfigureUsage={setUsageProvider}
                       onOpenWebsite={handleOpenWebsite}
@@ -655,6 +790,9 @@ function App() {
                         activeApp === "claude" ? handleOpenTerminal : undefined
                       }
                       onCreate={() => setIsAddOpen(true)}
+                      onSetAsDefault={
+                        activeApp === "openclaw" ? setAsDefaultModel : undefined
+                      }
                     />
                   </motion.div>
                 </AnimatePresence>
@@ -764,6 +902,11 @@ function App() {
                       defaultValue: "统一供应商",
                     })}
                   {currentView === "sessions" && t("sessionManager.title")}
+                  {currentView === "workspace" && t("workspace.title")}
+                  {currentView === "openclawEnv" && t("openclaw.env.title")}
+                  {currentView === "openclawTools" && t("openclaw.tools.title")}
+                  {currentView === "openclawAgents" &&
+                    t("openclaw.agents.title")}
                 </h1>
               </div>
             ) : (
@@ -821,191 +964,267 @@ function App() {
             )}
           </div>
 
-          <div
-            className="flex items-center gap-1.5 h-[32px]"
-            style={{ WebkitAppRegion: "no-drag" } as any}
-          >
-            {currentView === "prompts" && (
-              <Button
-                variant="ghost"
-                size="sm"
-                onClick={() => promptPanelRef.current?.openAdd()}
-                className="hover:bg-black/5 dark:hover:bg-white/5"
+          <div className="flex flex-1 min-w-0 items-center justify-end gap-1.5">
+            {currentView === "providers" &&
+              activeApp !== "opencode" &&
+              activeApp !== "openclaw" &&
+              settingsData?.enableLocalProxy && (
+                <div
+                  className="flex shrink-0 items-center gap-1.5"
+                  style={{ WebkitAppRegion: "no-drag" } as any}
+                >
+                  <ProxyToggle activeApp={activeApp} />
+                  <div
+                    className={cn(
+                      "transition-all duration-300 ease-in-out overflow-hidden",
+                      isCurrentAppTakeoverActive
+                        ? "opacity-100 max-w-[100px] scale-100"
+                        : "opacity-0 max-w-0 scale-75 pointer-events-none",
+                    )}
+                  >
+                    <FailoverToggle activeApp={activeApp} />
+                  </div>
+                </div>
+              )}
+            <div
+              ref={toolbarRef}
+              className="flex flex-1 min-w-0 overflow-x-hidden justify-end items-center"
+            >
+              <div
+                className="flex shrink-0 items-center gap-1.5"
+                style={{ WebkitAppRegion: "no-drag" } as any}
               >
-                <Plus className="w-4 h-4 mr-2" />
-                {t("prompts.add")}
-              </Button>
-            )}
-            {currentView === "mcp" && (
-              <>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => mcpPanelRef.current?.openImport()}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <Download className="w-4 h-4 mr-2" />
-                  {t("mcp.importExisting")}
-                </Button>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => mcpPanelRef.current?.openAdd()}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <Plus className="w-4 h-4 mr-2" />
-                  {t("mcp.addMcp")}
-                </Button>
-              </>
-            )}
-            {currentView === "skills" && (
-              <>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() =>
-                    unifiedSkillsPanelRef.current?.openInstallFromZip()
-                  }
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <FolderArchive className="w-4 h-4 mr-2" />
-                  {t("skills.installFromZip.button")}
-                </Button>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => unifiedSkillsPanelRef.current?.openImport()}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <Download className="w-4 h-4 mr-2" />
-                  {t("skills.import")}
-                </Button>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => setCurrentView("skillsDiscovery")}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <Search className="w-4 h-4 mr-2" />
-                  {t("skills.discover")}
-                </Button>
-              </>
-            )}
-            {currentView === "skillsDiscovery" && (
-              <>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => skillsPageRef.current?.refresh()}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <RefreshCw className="w-4 h-4 mr-2" />
-                  {t("skills.refresh")}
-                </Button>
-                <Button
-                  variant="ghost"
-                  size="sm"
-                  onClick={() => skillsPageRef.current?.openRepoManager()}
-                  className="hover:bg-black/5 dark:hover:bg-white/5"
-                >
-                  <Settings className="w-4 h-4 mr-2" />
-                  {t("skills.repoManager")}
-                </Button>
-              </>
-            )}
-            {currentView === "providers" && (
-              <>
-                {activeApp !== "opencode" && (
+                {currentView === "prompts" && (
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => promptPanelRef.current?.openAdd()}
+                    className="hover:bg-black/5 dark:hover:bg-white/5"
+                  >
+                    <Plus className="w-4 h-4 mr-2" />
+                    {t("prompts.add")}
+                  </Button>
+                )}
+                {currentView === "mcp" && (
                   <>
-                    <ProxyToggle activeApp={activeApp} />
-                    <div
-                      className={cn(
-                        "transition-all duration-300 ease-in-out overflow-hidden",
-                        isCurrentAppTakeoverActive
-                          ? "opacity-100 max-w-[100px] scale-100"
-                          : "opacity-0 max-w-0 scale-75 pointer-events-none",
-                      )}
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => mcpPanelRef.current?.openImport()}
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
                     >
-                      <FailoverToggle activeApp={activeApp} />
-                    </div>
+                      <Download className="w-4 h-4 mr-2" />
+                      {t("mcp.importExisting")}
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => mcpPanelRef.current?.openAdd()}
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <Plus className="w-4 h-4 mr-2" />
+                      {t("mcp.addMcp")}
+                    </Button>
                   </>
                 )}
+                {currentView === "skills" && (
+                  <>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() =>
+                        unifiedSkillsPanelRef.current?.openInstallFromZip()
+                      }
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <FolderArchive className="w-4 h-4 mr-2" />
+                      {t("skills.installFromZip.button")}
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() =>
+                        unifiedSkillsPanelRef.current?.openImport()
+                      }
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <Download className="w-4 h-4 mr-2" />
+                      {t("skills.import")}
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => setCurrentView("skillsDiscovery")}
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <Search className="w-4 h-4 mr-2" />
+                      {t("skills.discover")}
+                    </Button>
+                  </>
+                )}
+                {currentView === "skillsDiscovery" && (
+                  <>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => skillsPageRef.current?.refresh()}
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <RefreshCw className="w-4 h-4 mr-2" />
+                      {t("skills.refresh")}
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => skillsPageRef.current?.openRepoManager()}
+                      className="hover:bg-black/5 dark:hover:bg-white/5"
+                    >
+                      <Settings className="w-4 h-4 mr-2" />
+                      {t("skills.repoManager")}
+                    </Button>
+                  </>
+                )}
+                {currentView === "providers" && (
+                  <>
+                    <AppSwitcher
+                      activeApp={activeApp}
+                      onSwitch={setActiveApp}
+                      visibleApps={visibleApps}
+                      compact={isToolbarCompact}
+                    />
 
-                <AppSwitcher
-                  activeApp={activeApp}
-                  onSwitch={setActiveApp}
-                  visibleApps={visibleApps}
-                  compact={
-                    isCurrentAppTakeoverActive &&
-                    Object.values(visibleApps).filter(Boolean).length >= 4
-                  }
-                />
+                    <div className="flex items-center gap-1 p-1 bg-muted rounded-xl">
+                      <AnimatePresence mode="wait">
+                        <motion.div
+                          key={
+                            activeApp === "openclaw" ? "openclaw" : "default"
+                          }
+                          className="flex items-center gap-1"
+                          initial={{ opacity: 0 }}
+                          animate={{ opacity: 1 }}
+                          exit={{ opacity: 0 }}
+                          transition={{ duration: 0.15 }}
+                        >
+                          {activeApp === "openclaw" ? (
+                            <>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("workspace")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("workspace.manage")}
+                              >
+                                <FolderOpen className="w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("openclawEnv")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("openclaw.env.title")}
+                              >
+                                <KeyRound className="w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("openclawTools")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("openclaw.tools.title")}
+                              >
+                                <Shield className="w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("openclawAgents")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("openclaw.agents.title")}
+                              >
+                                <Cpu className="w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("sessions")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("sessionManager.title")}
+                              >
+                                <History className="w-4 h-4" />
+                              </Button>
+                            </>
+                          ) : (
+                            <>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("skills")}
+                                className={cn(
+                                  "text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5",
+                                  "transition-all duration-200 ease-in-out overflow-hidden",
+                                  hasSkillsSupport
+                                    ? "opacity-100 w-8 scale-100 px-2"
+                                    : "opacity-0 w-0 scale-75 pointer-events-none px-0 -ml-1",
+                                )}
+                                title={t("skills.manage")}
+                              >
+                                <Wrench className="flex-shrink-0 w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("prompts")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("prompts.manage")}
+                              >
+                                <Book className="w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("sessions")}
+                                className={cn(
+                                  "text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5",
+                                  "transition-all duration-200 ease-in-out overflow-hidden",
+                                  hasSessionSupport
+                                    ? "opacity-100 w-8 scale-100 px-2"
+                                    : "opacity-0 w-0 scale-75 pointer-events-none px-0 -ml-1",
+                                )}
+                                title={t("sessionManager.title")}
+                              >
+                                <History className="flex-shrink-0 w-4 h-4" />
+                              </Button>
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                onClick={() => setCurrentView("mcp")}
+                                className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
+                                title={t("mcp.title")}
+                              >
+                                <McpIcon size={16} />
+                              </Button>
+                            </>
+                          )}
+                        </motion.div>
+                      </AnimatePresence>
+                    </div>
 
-                <div className="flex items-center gap-1 p-1 bg-muted rounded-xl">
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => setCurrentView("skills")}
-                    className={cn(
-                      "text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5",
-                      "transition-all duration-200 ease-in-out overflow-hidden",
-                      hasSkillsSupport
-                        ? "opacity-100 w-8 scale-100 px-2"
-                        : "opacity-0 w-0 scale-75 pointer-events-none px-0 -ml-1",
-                    )}
-                    title={t("skills.manage")}
-                  >
-                    <Wrench className="flex-shrink-0 w-4 h-4" />
-                  </Button>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => setCurrentView("prompts")}
-                    className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
-                    title={t("prompts.manage")}
-                  >
-                    <Book className="w-4 h-4" />
-                  </Button>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => setCurrentView("sessions")}
-                    className={cn(
-                      "text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5",
-                      "transition-all duration-200 ease-in-out overflow-hidden",
-                      hasSessionSupport
-                        ? "opacity-100 w-8 scale-100 px-2"
-                        : "opacity-0 w-0 scale-75 pointer-events-none px-0 -ml-1",
-                    )}
-                    title={t("sessionManager.title")}
-                  >
-                    <History className="flex-shrink-0 w-4 h-4" />
-                  </Button>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => setCurrentView("mcp")}
-                    className="text-muted-foreground hover:text-foreground hover:bg-black/5 dark:hover:bg-white/5"
-                    title={t("mcp.title")}
-                  >
-                    <McpIcon size={16} />
-                  </Button>
-                </div>
-
-                <Button
-                  onClick={() => setIsAddOpen(true)}
-                  size="icon"
-                  className={`ml-2 ${addActionButtonClass}`}
-                >
-                  <Plus className="w-5 h-5" />
-                </Button>
-              </>
-            )}
+                    <Button
+                      onClick={() => setIsAddOpen(true)}
+                      size="icon"
+                      className={`ml-2 ${addActionButtonClass}`}
+                    >
+                      <Plus className="w-5 h-5" />
+                    </Button>
+                  </>
+                )}
+              </div>
+            </div>
           </div>
         </div>
       </header>
 
-      <main className="flex-1 min-h-0 flex flex-col animate-fade-in">
+      <main className="flex-1 min-h-0 flex flex-col overflow-y-auto animate-fade-in">
         {renderContent()}
       </main>
 

src/components/AppSwitcher.tsx

@@ -1,6 +1,7 @@
 import type { AppId } from "@/lib/api";
 import type { VisibleApps } from "@/types";
 import { ProviderIcon } from "@/components/ProviderIcon";
+import { cn } from "@/lib/utils";
 
 interface AppSwitcherProps {
   activeApp: AppId;
@@ -9,7 +10,7 @@ interface AppSwitcherProps {
   compact?: boolean;
 }
 
-const ALL_APPS: AppId[] = ["claude", "codex", "gemini", "opencode"];
+const ALL_APPS: AppId[] = ["claude", "codex", "gemini", "opencode", "openclaw"];
 const STORAGE_KEY = "cc-switch-last-app";
 
 export function AppSwitcher({
@@ -29,12 +30,14 @@ export function AppSwitcher({
     codex: "openai",
     gemini: "gemini",
     opencode: "opencode",
+    openclaw: "openclaw",
   };
   const appDisplayName: Record<AppId, string> = {
     claude: "Claude",
     codex: "Codex",
     gemini: "Gemini",
     opencode: "OpenCode",
+    openclaw: "OpenClaw",
   };
 
   // Filter apps based on visibility settings (default all visible)
@@ -50,18 +53,28 @@ export function AppSwitcher({
           key={app}
           type="button"
           onClick={() => handleSwitch(app)}
-          className={`group inline-flex items-center gap-2 px-3 h-8 rounded-md text-sm font-medium transition-all duration-200 ${
+          className={cn(
+            "group inline-flex items-center px-3 h-8 rounded-md text-sm font-medium transition-all duration-200",
             activeApp === app
               ? "bg-background text-foreground shadow-sm"
-              : "text-muted-foreground hover:text-foreground hover:bg-background/50"
-          }`}
+              : "text-muted-foreground hover:text-foreground hover:bg-background/50",
+          )}
         >
           <ProviderIcon
             icon={appIconName[app]}
             name={appDisplayName[app]}
             size={iconSize}
           />
-          {!compact && <span>{appDisplayName[app]}</span>}
+          <span
+            className={cn(
+              "transition-all duration-200 whitespace-nowrap overflow-hidden",
+              compact
+                ? "max-w-0 opacity-0 ml-0"
+                : "max-w-[80px] opacity-100 ml-2",
+            )}
+          >
+            {appDisplayName[app]}
+          </span>
         </button>
       ))}
     </div>

src/components/BrandIcons.tsx

@@ -7,6 +7,7 @@ interface IconProps {
 import ClaudeSvg from "@/icons/extracted/claude.svg?url";
 import OpenAISvg from "@/icons/extracted/openai.svg?url";
 import GeminiSvg from "@/icons/extracted/gemini.svg?url";
+import OpenClawSvg from "@/icons/extracted/claw.svg?url";
 
 export function ClaudeIcon({ size = 16, className = "" }: IconProps) {
   return (
@@ -47,6 +48,19 @@ export function GeminiIcon({ size = 16, className = "" }: IconProps) {
   );
 }
 
+export function OpenClawIcon({ size = 16, className = "" }: IconProps) {
+  return (
+    <img
+      src={OpenClawSvg}
+      width={size}
+      height={size}
+      className={className}
+      alt="OpenClaw"
+      loading="lazy"
+    />
+  );
+}
+
 // MCP icon uses inline SVG to support currentColor for hover effects
 export function McpIcon({ size = 16, className = "" }: IconProps) {
   return (

src/components/ConfirmDialog.tsx

@@ -7,7 +7,7 @@ import {
   DialogTitle,
 } from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
-import { AlertTriangle } from "lucide-react";
+import { AlertTriangle, Info } from "lucide-react";
 import { useTranslation } from "react-i18next";
 
 interface ConfirmDialogProps {
@@ -16,6 +16,7 @@ interface ConfirmDialogProps {
   message: string;
   confirmText?: string;
   cancelText?: string;
+  variant?: "destructive" | "info";
   onConfirm: () => void;
   onCancel: () => void;
 }
@@ -26,11 +27,16 @@ export function ConfirmDialog({
   message,
   confirmText,
   cancelText,
+  variant = "destructive",
   onConfirm,
   onCancel,
 }: ConfirmDialogProps) {
   const { t } = useTranslation();
 
+  const IconComponent = variant === "info" ? Info : AlertTriangle;
+  const iconClass =
+    variant === "info" ? "h-5 w-5 text-blue-500" : "h-5 w-5 text-destructive";
+
   return (
     <Dialog
       open={isOpen}
@@ -43,7 +49,7 @@ export function ConfirmDialog({
       <DialogContent className="max-w-sm" zIndex="alert">
         <DialogHeader className="space-y-3 border-b-0 bg-transparent pb-0">
           <DialogTitle className="flex items-center gap-2 text-lg font-semibold">
-            <AlertTriangle className="h-5 w-5 text-destructive" />
+            <IconComponent className={iconClass} />
             {title}
           </DialogTitle>
           <DialogDescription className="whitespace-pre-line text-sm leading-relaxed">
@@ -54,7 +60,10 @@ export function ConfirmDialog({
           <Button variant="outline" onClick={onCancel}>
             {cancelText || t("common.cancel")}
           </Button>
-          <Button variant="destructive" onClick={onConfirm}>
+          <Button
+            variant={variant === "info" ? "default" : "destructive"}
+            onClick={onConfirm}
+          >
             {confirmText || t("common.confirm")}
           </Button>
         </DialogFooter>

src/components/DeepLinkImportDialog.tsx

@@ -53,15 +53,12 @@ export function DeepLinkImportDialog() {
     const unlistenImport = listen<DeepLinkImportRequest>(
       "deeplink-import",
       async (event) => {
-        console.log("Deep link import event received:", event.payload);
-
         // If config is present, merge it to get the complete configuration
         if (event.payload.config || event.payload.configUrl) {
           try {
             const mergedRequest = await deeplinkApi.mergeDeeplinkConfig(
               event.payload,
             );
-            console.log("Config merged successfully:", mergedRequest);
             setRequest(mergedRequest);
           } catch (error) {
             console.error("Failed to merge config:", error);

src/components/UsageScriptModal.tsx

@@ -4,7 +4,8 @@ import { toast } from "sonner";
 import { useTranslation } from "react-i18next";
 import { useQueryClient } from "@tanstack/react-query";
 import { Provider, UsageScript, UsageData } from "@/types";
-import { usageApi, type AppId } from "@/lib/api";
+import { usageApi, settingsApi, type AppId } from "@/lib/api";
+import { useSettingsQuery } from "@/lib/query";
 import { extractCodexBaseUrl } from "@/utils/providerConfigUtils";
 import JsonEditor from "./JsonEditor";
 import * as prettier from "prettier/standalone";
@@ -15,6 +16,7 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Switch } from "@/components/ui/switch";
 import { FullScreenPanel } from "@/components/common/FullScreenPanel";
+import { ConfirmDialog } from "@/components/ConfirmDialog";
 import { cn } from "@/lib/utils";
 
 interface UsageScriptModalProps {
@@ -112,6 +114,8 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
 }) => {
   const { t } = useTranslation();
   const queryClient = useQueryClient();
+  const { data: settingsData } = useSettingsQuery();
+  const [showUsageConfirm, setShowUsageConfirm] = useState(false);
 
   // 生成带国际化的预设模板
   const PRESET_TEMPLATES = generatePresetTemplates(t);
@@ -247,6 +251,27 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
   const [showApiKey, setShowApiKey] = useState(false);
   const [showAccessToken, setShowAccessToken] = useState(false);
 
+  const handleEnableToggle = (checked: boolean) => {
+    if (checked && !settingsData?.usageConfirmed) {
+      setShowUsageConfirm(true);
+    } else {
+      setScript({ ...script, enabled: checked });
+    }
+  };
+
+  const handleUsageConfirm = async () => {
+    setShowUsageConfirm(false);
+    try {
+      if (settingsData) {
+        await settingsApi.save({ ...settingsData, usageConfirmed: true });
+        await queryClient.invalidateQueries({ queryKey: ["settings"] });
+      }
+    } catch (error) {
+      console.error("Failed to save usage confirmed:", error);
+    }
+    setScript({ ...script, enabled: true });
+  };
+
   const handleSave = () => {
     if (script.enabled && !script.code.trim()) {
       toast.error(t("usageScript.scriptEmpty"));
@@ -436,9 +461,7 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
         </p>
         <Switch
           checked={script.enabled}
-          onCheckedChange={(checked) =>
-            setScript({ ...script, enabled: checked })
-          }
+          onCheckedChange={handleEnableToggle}
           aria-label={t("usageScript.enableUsageQuery")}
         />
       </div>
@@ -844,6 +867,16 @@ const UsageScriptModal: React.FC<UsageScriptModalProps> = ({
           </div>
         </div>
       )}
+
+      <ConfirmDialog
+        isOpen={showUsageConfirm}
+        variant="info"
+        title={t("confirm.usage.title")}
+        message={t("confirm.usage.message")}
+        confirmText={t("confirm.usage.confirm")}
+        onConfirm={() => void handleUsageConfirm()}
+        onCancel={() => setShowUsageConfirm(false)}
+      />
     </FullScreenPanel>
   );
 };

src/components/common/AppCountBar.tsx

@@ -6,11 +6,13 @@ import { APP_IDS, APP_ICON_MAP } from "@/config/appConfig";
 interface AppCountBarProps {
   totalLabel: string;
   counts: Record<AppId, number>;
+  appIds?: AppId[];
 }
 
 export const AppCountBar: React.FC<AppCountBarProps> = ({
   totalLabel,
   counts,
+  appIds = APP_IDS,
 }) => {
   return (
     <div className="flex-shrink-0 py-4 glass rounded-xl border border-white/10 mb-4 px-6 flex items-center justify-between gap-4">
@@ -18,7 +20,7 @@ export const AppCountBar: React.FC<AppCountBarProps> = ({
         {totalLabel}
       </Badge>
       <div className="flex items-center gap-2 overflow-x-auto no-scrollbar">
-        {APP_IDS.map((app) => (
+        {appIds.map((app) => (
           <Badge
             key={app}
             variant="secondary"

src/components/common/AppToggleGroup.tsx

@@ -10,15 +10,17 @@ import { APP_IDS, APP_ICON_MAP } from "@/config/appConfig";
 interface AppToggleGroupProps {
   apps: Record<AppId, boolean>;
   onToggle: (app: AppId, enabled: boolean) => void;
+  appIds?: AppId[];
 }
 
 export const AppToggleGroup: React.FC<AppToggleGroupProps> = ({
   apps,
   onToggle,
+  appIds = APP_IDS,
 }) => {
   return (
     <div className="flex items-center gap-1.5 flex-shrink-0">
-      {APP_IDS.map((app) => {
+      {appIds.map((app) => {
         const { label, icon, activeClass } = APP_ICON_MAP[app];
         const enabled = apps[app];
         return (

src/components/mcp/McpFormModal.tsx

@@ -66,6 +66,7 @@ const McpFormModal: React.FC<McpFormModalProps> = ({
     codex: boolean;
     gemini: boolean;
     opencode: boolean;
+    openclaw: boolean;
   }>(() => {
     if (initialData?.apps) {
       return { ...initialData.apps };
@@ -75,6 +76,7 @@ const McpFormModal: React.FC<McpFormModalProps> = ({
       codex: defaultEnabledApps.includes("codex"),
       gemini: defaultEnabledApps.includes("gemini"),
       opencode: defaultEnabledApps.includes("opencode"),
+      openclaw: defaultEnabledApps.includes("openclaw"),
     };
   });
 

src/components/mcp/UnifiedMcpPanel.tsx

@@ -17,7 +17,7 @@ import { Edit3, Trash2, ExternalLink } from "lucide-react";
 import { settingsApi } from "@/lib/api";
 import { mcpPresets } from "@/config/mcpPresets";
 import { toast } from "sonner";
-import { APP_IDS } from "@/config/appConfig";
+import { MCP_SKILLS_APP_IDS } from "@/config/appConfig";
 import { AppCountBar } from "@/components/common/AppCountBar";
 import { AppToggleGroup } from "@/components/common/AppToggleGroup";
 import { ListItemRow } from "@/components/common/ListItemRow";
@@ -56,9 +56,9 @@ const UnifiedMcpPanel = React.forwardRef<
   }, [serversMap]);
 
   const enabledCounts = useMemo(() => {
-    const counts = { claude: 0, codex: 0, gemini: 0, opencode: 0 };
+    const counts = { claude: 0, codex: 0, gemini: 0, opencode: 0, openclaw: 0 };
     serverEntries.forEach(([_, server]) => {
-      for (const app of APP_IDS) {
+      for (const app of MCP_SKILLS_APP_IDS) {
         if (server.apps[app]) counts[app]++;
       }
     });
@@ -136,6 +136,7 @@ const UnifiedMcpPanel = React.forwardRef<
       <AppCountBar
         totalLabel={t("mcp.serverCount", { count: serverEntries.length })}
         counts={enabledCounts}
+        appIds={MCP_SKILLS_APP_IDS}
       />
 
       <div className="flex-1 overflow-y-auto overflow-x-hidden pb-24">
@@ -277,6 +278,7 @@ const UnifiedMcpListItem: React.FC<UnifiedMcpListItemProps> = ({
       <AppToggleGroup
         apps={server.apps}
         onToggle={(app, enabled) => onToggleApp(id, app, enabled)}
+        appIds={MCP_SKILLS_APP_IDS}
       />
 
       <div className="flex items-center gap-0.5 flex-shrink-0 opacity-0 group-hover:opacity-100 transition-opacity">

src/components/openclaw/AgentsDefaultsPanel.tsx

@@ -0,0 +1,230 @@
+import React, { useState, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { Save } from "lucide-react";
+import { toast } from "sonner";
+import {
+  useOpenClawAgentsDefaults,
+  useSaveOpenClawAgentsDefaults,
+} from "@/hooks/useOpenClaw";
+import { extractErrorMessage } from "@/utils/errorUtils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import type { OpenClawAgentsDefaults } from "@/types";
+
+const AgentsDefaultsPanel: React.FC = () => {
+  const { t } = useTranslation();
+  const { data: agentsData, isLoading } = useOpenClawAgentsDefaults();
+  const saveAgentsMutation = useSaveOpenClawAgentsDefaults();
+  const [defaults, setDefaults] = useState<OpenClawAgentsDefaults | null>(null);
+  const [fallbacks, setFallbacks] = useState("");
+
+  // Extra known fields from agents.defaults
+  const [workspace, setWorkspace] = useState("");
+  const [timeout, setTimeout_] = useState("");
+  const [contextTokens, setContextTokens] = useState("");
+  const [maxConcurrent, setMaxConcurrent] = useState("");
+
+  // Primary model is read-only — set via the "Set as default model" button on provider cards
+  const primaryModel = agentsData?.model?.primary ?? "";
+
+  useEffect(() => {
+    // agentsData is undefined while loading, null when config section is absent
+    if (agentsData === undefined) return;
+    setDefaults(agentsData);
+
+    if (agentsData) {
+      setFallbacks((agentsData.model?.fallbacks ?? []).join(", "));
+
+      // Extract known extra fields
+      setWorkspace(String(agentsData.workspace ?? ""));
+      setTimeout_(String(agentsData.timeout ?? ""));
+      setContextTokens(String(agentsData.contextTokens ?? ""));
+      setMaxConcurrent(String(agentsData.maxConcurrent ?? ""));
+    }
+  }, [agentsData]);
+
+  const handleSave = async () => {
+    try {
+      // Preserve all unknown fields from original data
+      const updated: OpenClawAgentsDefaults = { ...defaults };
+
+      // Model configuration — primary is read-only, preserve original value
+      const fallbackList = fallbacks
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+
+      const origPrimary = defaults?.model?.primary;
+      if (origPrimary) {
+        updated.model = {
+          primary: origPrimary,
+          ...(fallbackList.length > 0 ? { fallbacks: fallbackList } : {}),
+        };
+      } else if (fallbackList.length > 0) {
+        // No primary set but user provided fallbacks — keep fallbacks only
+        updated.model = { primary: "", fallbacks: fallbackList };
+      }
+
+      // Optional fields
+      if (workspace.trim()) updated.workspace = workspace.trim();
+      else delete updated.workspace;
+
+      // Numeric fields: validate before saving to avoid NaN
+      const parseNum = (v: string) => {
+        const n = Number(v);
+        return !isNaN(n) && isFinite(n) ? n : undefined;
+      };
+
+      const timeoutNum = timeout.trim() ? parseNum(timeout) : undefined;
+      if (timeoutNum !== undefined) updated.timeout = timeoutNum;
+      else delete updated.timeout;
+
+      const ctxNum = contextTokens.trim() ? parseNum(contextTokens) : undefined;
+      if (ctxNum !== undefined) updated.contextTokens = ctxNum;
+      else delete updated.contextTokens;
+
+      const concNum = maxConcurrent.trim()
+        ? parseNum(maxConcurrent)
+        : undefined;
+      if (concNum !== undefined) updated.maxConcurrent = concNum;
+      else delete updated.maxConcurrent;
+
+      await saveAgentsMutation.mutateAsync(updated);
+      toast.success(t("openclaw.agents.saveSuccess"));
+    } catch (error) {
+      const detail = extractErrorMessage(error);
+      toast.error(t("openclaw.agents.saveFailed"), {
+        description: detail || undefined,
+      });
+    }
+  };
+
+  if (isLoading) {
+    return (
+      <div className="px-6 pt-4 pb-8 flex items-center justify-center min-h-[200px]">
+        <div className="text-sm text-muted-foreground">
+          {t("common.loading")}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="px-6 pt-4 pb-8">
+      <p className="text-sm text-muted-foreground mb-6">
+        {t("openclaw.agents.description")}
+      </p>
+
+      {/* Model Configuration Card */}
+      <div className="rounded-xl border border-border bg-card p-5 mb-4">
+        <h3 className="text-sm font-medium mb-4">
+          {t("openclaw.agents.modelSection")}
+        </h3>
+
+        <div className="space-y-4">
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.primaryModel")}
+            </Label>
+            <div className="h-9 px-3 flex items-center rounded-md border border-input bg-muted/50 font-mono text-xs text-muted-foreground">
+              {primaryModel || t("openclaw.agents.notSet")}
+            </div>
+            <p className="text-xs text-muted-foreground mt-1">
+              {t("openclaw.agents.primaryModelHint")}
+            </p>
+          </div>
+
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.fallbackModels")}
+            </Label>
+            <Input
+              value={fallbacks}
+              onChange={(e) => setFallbacks(e.target.value)}
+              placeholder="provider/model-a, provider/model-b"
+              className="font-mono text-xs"
+            />
+            <p className="text-xs text-muted-foreground mt-1">
+              {t("openclaw.agents.fallbackModelsHint")}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      {/* Runtime Parameters Card */}
+      <div className="rounded-xl border border-border bg-card p-5 mb-4">
+        <h3 className="text-sm font-medium mb-4">
+          {t("openclaw.agents.runtimeSection")}
+        </h3>
+
+        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.workspace")}
+            </Label>
+            <Input
+              value={workspace}
+              onChange={(e) => setWorkspace(e.target.value)}
+              placeholder="~/projects"
+              className="font-mono text-xs"
+            />
+          </div>
+
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.timeout")}
+            </Label>
+            <Input
+              type="number"
+              value={timeout}
+              onChange={(e) => setTimeout_(e.target.value)}
+              placeholder="300"
+              className="font-mono text-xs"
+            />
+          </div>
+
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.contextTokens")}
+            </Label>
+            <Input
+              type="number"
+              value={contextTokens}
+              onChange={(e) => setContextTokens(e.target.value)}
+              placeholder="200000"
+              className="font-mono text-xs"
+            />
+          </div>
+
+          <div>
+            <Label className="mb-1.5 block">
+              {t("openclaw.agents.maxConcurrent")}
+            </Label>
+            <Input
+              type="number"
+              value={maxConcurrent}
+              onChange={(e) => setMaxConcurrent(e.target.value)}
+              placeholder="4"
+              className="font-mono text-xs"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Save button */}
+      <div className="flex justify-end">
+        <Button
+          size="sm"
+          onClick={handleSave}
+          disabled={saveAgentsMutation.isPending}
+        >
+          <Save className="w-4 h-4 mr-1" />
+          {saveAgentsMutation.isPending ? t("common.saving") : t("common.save")}
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+export default AgentsDefaultsPanel;

src/components/openclaw/EnvPanel.tsx

@@ -0,0 +1,182 @@
+import React, { useState, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { Plus, Trash2, Save, Eye, EyeOff } from "lucide-react";
+import { toast } from "sonner";
+import { useOpenClawEnv, useSaveOpenClawEnv } from "@/hooks/useOpenClaw";
+import { extractErrorMessage } from "@/utils/errorUtils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import type { OpenClawEnvConfig } from "@/types";
+
+interface EnvEntry {
+  id: string;
+  key: string;
+  value: string;
+  isNew?: boolean;
+}
+
+const EnvPanel: React.FC = () => {
+  const { t } = useTranslation();
+  const { data: envData, isLoading } = useOpenClawEnv();
+  const saveEnvMutation = useSaveOpenClawEnv();
+  const [entries, setEntries] = useState<EnvEntry[]>([]);
+  const [visibleKeys, setVisibleKeys] = useState<Set<string>>(new Set());
+
+  useEffect(() => {
+    if (envData) {
+      const items: EnvEntry[] = Object.entries(envData).map(([key, value]) => ({
+        id: crypto.randomUUID(),
+        key,
+        value: String(value ?? ""),
+      }));
+      setEntries(items.length > 0 ? items : []);
+    }
+  }, [envData]);
+
+  const handleSave = async () => {
+    try {
+      const env: OpenClawEnvConfig = {};
+      const seen = new Set<string>();
+      for (const entry of entries) {
+        const trimmedKey = entry.key.trim();
+        if (trimmedKey) {
+          if (seen.has(trimmedKey)) {
+            toast.error(t("openclaw.env.duplicateKey", { key: trimmedKey }));
+            return;
+          }
+          seen.add(trimmedKey);
+          env[trimmedKey] = entry.value;
+        }
+      }
+      await saveEnvMutation.mutateAsync(env);
+      toast.success(t("openclaw.env.saveSuccess"));
+    } catch (error) {
+      const detail = extractErrorMessage(error);
+      toast.error(t("openclaw.env.saveFailed"), {
+        description: detail || undefined,
+      });
+    }
+  };
+
+  const addEntry = () => {
+    setEntries((prev) => [
+      ...prev,
+      { id: crypto.randomUUID(), key: "", value: "", isNew: true },
+    ]);
+  };
+
+  const removeEntry = (index: number) => {
+    setEntries((prev) => prev.filter((_, i) => i !== index));
+  };
+
+  const updateEntry = (index: number, field: "key" | "value", val: string) => {
+    setEntries((prev) =>
+      prev.map((entry, i) =>
+        i === index ? { ...entry, [field]: val } : entry,
+      ),
+    );
+  };
+
+  const toggleVisibility = (key: string) => {
+    setVisibleKeys((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) {
+        next.delete(key);
+      } else {
+        next.add(key);
+      }
+      return next;
+    });
+  };
+
+  const isApiKey = (key: string) => /key|token|secret|password/i.test(key);
+
+  if (isLoading) {
+    return (
+      <div className="px-6 pt-4 pb-8 flex items-center justify-center min-h-[200px]">
+        <div className="text-sm text-muted-foreground">
+          {t("common.loading")}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="px-6 pt-4 pb-8">
+      <p className="text-sm text-muted-foreground mb-4">
+        {t("openclaw.env.description")}
+      </p>
+
+      <div className="space-y-3">
+        {entries.map((entry, index) => {
+          const sensitive = isApiKey(entry.key);
+          const visibilityId = entry.key || `__new_${index}`;
+          const visible = visibleKeys.has(visibilityId);
+
+          return (
+            <div key={entry.id} className="flex items-center gap-2">
+              <div className="w-[200px] flex-shrink-0">
+                <Input
+                  value={entry.key}
+                  onChange={(e) => updateEntry(index, "key", e.target.value)}
+                  placeholder={t("openclaw.env.keyPlaceholder")}
+                  className="font-mono text-xs"
+                  autoFocus={entry.isNew}
+                />
+              </div>
+              <div className="flex-1 flex items-center gap-1">
+                <Input
+                  type={sensitive && !visible ? "password" : "text"}
+                  value={entry.value}
+                  onChange={(e) => updateEntry(index, "value", e.target.value)}
+                  placeholder={t("openclaw.env.valuePlaceholder")}
+                  className="font-mono text-xs"
+                />
+                {sensitive && (
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="flex-shrink-0 h-9 w-9 text-muted-foreground"
+                    onClick={() => toggleVisibility(visibilityId)}
+                  >
+                    {visible ? (
+                      <EyeOff className="w-4 h-4" />
+                    ) : (
+                      <Eye className="w-4 h-4" />
+                    )}
+                  </Button>
+                )}
+              </div>
+              <Button
+                variant="ghost"
+                size="icon"
+                className="flex-shrink-0 h-9 w-9 text-muted-foreground hover:text-destructive"
+                onClick={() => removeEntry(index)}
+              >
+                <Trash2 className="w-4 h-4" />
+              </Button>
+            </div>
+          );
+        })}
+      </div>
+
+      <div className="flex items-center gap-2 mt-4">
+        <Button variant="outline" size="sm" onClick={addEntry}>
+          <Plus className="w-4 h-4 mr-1" />
+          {t("openclaw.env.add")}
+        </Button>
+        <div className="flex-1" />
+        <Button
+          size="sm"
+          onClick={handleSave}
+          disabled={saveEnvMutation.isPending}
+        >
+          <Save className="w-4 h-4 mr-1" />
+          {saveEnvMutation.isPending ? t("common.saving") : t("common.save")}
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+export default EnvPanel;

src/components/openclaw/ToolsPanel.tsx

@@ -0,0 +1,221 @@
+import React, { useState, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { Plus, Trash2, Save } from "lucide-react";
+import { toast } from "sonner";
+import { useOpenClawTools, useSaveOpenClawTools } from "@/hooks/useOpenClaw";
+import { extractErrorMessage } from "@/utils/errorUtils";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import type { OpenClawToolsConfig } from "@/types";
+
+interface ListItem {
+  id: string;
+  value: string;
+}
+
+const PROFILE_OPTIONS = ["default", "strict", "permissive", "custom"];
+
+const ToolsPanel: React.FC = () => {
+  const { t } = useTranslation();
+  const { data: toolsData, isLoading } = useOpenClawTools();
+  const saveToolsMutation = useSaveOpenClawTools();
+  const [config, setConfig] = useState<OpenClawToolsConfig>({});
+  const [allowList, setAllowList] = useState<ListItem[]>([]);
+  const [denyList, setDenyList] = useState<ListItem[]>([]);
+
+  useEffect(() => {
+    if (toolsData) {
+      setConfig(toolsData);
+      setAllowList(
+        (toolsData.allow ?? []).map((v) => ({
+          id: crypto.randomUUID(),
+          value: v,
+        })),
+      );
+      setDenyList(
+        (toolsData.deny ?? []).map((v) => ({
+          id: crypto.randomUUID(),
+          value: v,
+        })),
+      );
+    }
+  }, [toolsData]);
+
+  const handleSave = async () => {
+    try {
+      const { profile, allow, deny, ...other } = config;
+      const newConfig: OpenClawToolsConfig = {
+        ...other,
+        profile: config.profile,
+        allow: allowList.map((item) => item.value).filter((s) => s.trim()),
+        deny: denyList.map((item) => item.value).filter((s) => s.trim()),
+      };
+      await saveToolsMutation.mutateAsync(newConfig);
+      toast.success(t("openclaw.tools.saveSuccess"));
+    } catch (error) {
+      const detail = extractErrorMessage(error);
+      toast.error(t("openclaw.tools.saveFailed"), {
+        description: detail || undefined,
+      });
+    }
+  };
+
+  const updateListItem = (
+    setList: React.Dispatch<React.SetStateAction<ListItem[]>>,
+    index: number,
+    value: string,
+  ) => {
+    setList((prev) =>
+      prev.map((item, i) => (i === index ? { ...item, value } : item)),
+    );
+  };
+
+  const removeListItem = (
+    setList: React.Dispatch<React.SetStateAction<ListItem[]>>,
+    index: number,
+  ) => {
+    setList((prev) => prev.filter((_, i) => i !== index));
+  };
+
+  if (isLoading) {
+    return (
+      <div className="px-6 pt-4 pb-8 flex items-center justify-center min-h-[200px]">
+        <div className="text-sm text-muted-foreground">
+          {t("common.loading")}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="px-6 pt-4 pb-8">
+      <p className="text-sm text-muted-foreground mb-6">
+        {t("openclaw.tools.description")}
+      </p>
+
+      {/* Profile selector */}
+      <div className="mb-6">
+        <Label className="mb-2 block">{t("openclaw.tools.profile")}</Label>
+        <Select
+          value={config.profile ?? "default"}
+          onValueChange={(val) =>
+            setConfig((prev) => ({ ...prev, profile: val }))
+          }
+        >
+          <SelectTrigger className="w-[200px]">
+            <SelectValue />
+          </SelectTrigger>
+          <SelectContent>
+            {PROFILE_OPTIONS.map((opt) => (
+              <SelectItem key={opt} value={opt}>
+                {t(`openclaw.tools.profiles.${opt}`)}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      {/* Allow list */}
+      <div className="mb-6">
+        <Label className="mb-2 block">{t("openclaw.tools.allowList")}</Label>
+        <div className="space-y-2">
+          {allowList.map((item, index) => (
+            <div key={item.id} className="flex items-center gap-2">
+              <Input
+                value={item.value}
+                onChange={(e) =>
+                  updateListItem(setAllowList, index, e.target.value)
+                }
+                placeholder={t("openclaw.tools.patternPlaceholder")}
+                className="font-mono text-xs"
+              />
+              <Button
+                variant="ghost"
+                size="icon"
+                className="flex-shrink-0 h-9 w-9 text-muted-foreground hover:text-destructive"
+                onClick={() => removeListItem(setAllowList, index)}
+              >
+                <Trash2 className="w-4 h-4" />
+              </Button>
+            </div>
+          ))}
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() =>
+              setAllowList((prev) => [
+                ...prev,
+                { id: crypto.randomUUID(), value: "" },
+              ])
+            }
+          >
+            <Plus className="w-4 h-4 mr-1" />
+            {t("openclaw.tools.addAllow")}
+          </Button>
+        </div>
+      </div>
+
+      {/* Deny list */}
+      <div className="mb-6">
+        <Label className="mb-2 block">{t("openclaw.tools.denyList")}</Label>
+        <div className="space-y-2">
+          {denyList.map((item, index) => (
+            <div key={item.id} className="flex items-center gap-2">
+              <Input
+                value={item.value}
+                onChange={(e) =>
+                  updateListItem(setDenyList, index, e.target.value)
+                }
+                placeholder={t("openclaw.tools.patternPlaceholder")}
+                className="font-mono text-xs"
+              />
+              <Button
+                variant="ghost"
+                size="icon"
+                className="flex-shrink-0 h-9 w-9 text-muted-foreground hover:text-destructive"
+                onClick={() => removeListItem(setDenyList, index)}
+              >
+                <Trash2 className="w-4 h-4" />
+              </Button>
+            </div>
+          ))}
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() =>
+              setDenyList((prev) => [
+                ...prev,
+                { id: crypto.randomUUID(), value: "" },
+              ])
+            }
+          >
+            <Plus className="w-4 h-4 mr-1" />
+            {t("openclaw.tools.addDeny")}
+          </Button>
+        </div>
+      </div>
+
+      {/* Save button */}
+      <div className="flex justify-end">
+        <Button
+          size="sm"
+          onClick={handleSave}
+          disabled={saveToolsMutation.isPending}
+        >
+          <Save className="w-4 h-4 mr-1" />
+          {saveToolsMutation.isPending ? t("common.saving") : t("common.save")}
+        </Button>
+      </div>
+    </div>
+  );
+};
+
+export default ToolsPanel;

src/components/prompts/PromptFormModal.tsx

@@ -30,13 +30,13 @@ const PromptFormModal: React.FC<PromptFormModalProps> = ({
 }) => {
   const { t } = useTranslation();
   const appName = t(`apps.${appId}`);
-  const filenameMap: Record<AppId, string> = {
+  const filenameMap: Record<Exclude<AppId, "openclaw">, string> = {
     claude: "CLAUDE.md",
     codex: "AGENTS.md",
     gemini: "GEMINI.md",
     opencode: "AGENTS.md",
   };
-  const filename = filenameMap[appId];
+  const filename = filenameMap[appId as Exclude<AppId, "openclaw">];
   const [name, setName] = useState("");
   const [description, setDescription] = useState("");
   const [content, setContent] = useState("");

src/components/prompts/PromptFormPanel.tsx

@@ -29,6 +29,7 @@ const PromptFormPanel: React.FC<PromptFormPanelProps> = ({
     codex: "AGENTS.md",
     gemini: "GEMINI.md",
     opencode: "AGENTS.md",
+    openclaw: "AGENTS.md",
   };
   const filename = filenameMap[appId];
   const [name, setName] = useState("");

src/components/providers/AddProviderDialog.tsx

@@ -17,6 +17,7 @@ import { UniversalProviderPanel } from "@/components/universal";
 import { providerPresets } from "@/config/claudeProviderPresets";
 import { codexProviderPresets } from "@/config/codexProviderPresets";
 import { geminiProviderPresets } from "@/config/geminiProviderPresets";
+import type { OpenClawSuggestedDefaults } from "@/config/openclawProviderPresets";
 import type { UniversalProviderPreset } from "@/config/universalProviderPresets";
 
 interface AddProviderDialogProps {
@@ -24,7 +25,10 @@ interface AddProviderDialogProps {
   onOpenChange: (open: boolean) => void;
   appId: AppId;
   onSubmit: (
-    provider: Omit<Provider, "id"> & { providerKey?: string },
+    provider: Omit<Provider, "id"> & {
+      providerKey?: string;
+      suggestedDefaults?: OpenClawSuggestedDefaults;
+    },
   ) => Promise<void> | void;
 }
 
@@ -35,7 +39,8 @@ export function AddProviderDialog({
   onSubmit,
 }: AddProviderDialogProps) {
   const { t } = useTranslation();
-  const showUniversalTab = appId !== "opencode";
+  // OpenCode and OpenClaw don't support universal providers
+  const showUniversalTab = appId !== "opencode" && appId !== "openclaw";
   const [activeTab, setActiveTab] = useState<"app-specific" | "universal">(
     "app-specific",
   );
@@ -82,7 +87,11 @@ export function AddProviderDialog({
         unknown
       >;
 
-      const providerData: Omit<Provider, "id"> & { providerKey?: string } = {
+      // 构造基础提交数据
+      const providerData: Omit<Provider, "id"> & {
+        providerKey?: string;
+        suggestedDefaults?: OpenClawSuggestedDefaults;
+      } = {
         name: values.name.trim(),
         notes: values.notes?.trim() || undefined,
         websiteUrl: values.websiteUrl?.trim() || undefined,
@@ -93,7 +102,11 @@ export function AddProviderDialog({
         ...(values.meta ? { meta: values.meta } : {}),
       };
 
-      if (appId === "opencode" && values.providerKey) {
+      // OpenCode/OpenClaw: pass providerKey for ID generation
+      if (
+        (appId === "opencode" || appId === "openclaw") &&
+        values.providerKey
+      ) {
         providerData.providerKey = values.providerKey;
       }
 
@@ -185,6 +198,11 @@ export function AddProviderDialog({
           if (options?.baseURL) {
             addUrl(options.baseURL);
           }
+        } else if (appId === "openclaw") {
+          // OpenClaw uses baseUrl directly
+          if (parsedConfig.baseUrl) {
+            addUrl(parsedConfig.baseUrl as string);
+          }
         }
 
         const urls = Array.from(urlSet);
@@ -206,6 +224,11 @@ export function AddProviderDialog({
         }
       }
 
+      // OpenClaw: pass suggestedDefaults for model registration
+      if (appId === "openclaw" && values.suggestedDefaults) {
+        providerData.suggestedDefaults = values.suggestedDefaults;
+      }
+
       await onSubmit(providerData);
       onOpenChange(false);
     },
@@ -286,6 +309,7 @@ export function AddProviderDialog({
           </TabsContent>
         </Tabs>
       ) : (
+        // OpenCode/OpenClaw: directly show form without tabs
         <ProviderForm
           appId={appId}
           submitLabel={t("common.add")}

src/components/providers/ProviderActions.tsx

@@ -3,13 +3,14 @@ import {
   Check,
   Copy,
   Edit,
-  Loader2,
+  // Loader2, // Hidden: stream check feature disabled
   Minus,
   Play,
   Plus,
   Terminal,
-  TestTube2,
+  // TestTube2, // Hidden: stream check feature disabled
   Trash2,
+  Zap,
 } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { Button } from "@/components/ui/button";
@@ -23,7 +24,6 @@ interface ProviderActionsProps {
   isTesting?: boolean;
   isProxyTakeover?: boolean;
   isOmo?: boolean;
-  isLastOmo?: boolean;
   onSwitch: () => void;
   onEdit: () => void;
   onDuplicate: () => void;
@@ -36,20 +36,22 @@ interface ProviderActionsProps {
   isAutoFailoverEnabled?: boolean;
   isInFailoverQueue?: boolean;
   onToggleFailover?: (enabled: boolean) => void;
+  // OpenClaw: default model
+  isDefaultModel?: boolean;
+  onSetAsDefault?: () => void;
 }
 
 export function ProviderActions({
   appId,
   isCurrent,
   isInConfig = false,
-  isTesting,
+  isTesting: _isTesting, // Hidden: stream check feature disabled
   isProxyTakeover = false,
   isOmo = false,
-  isLastOmo = false,
   onSwitch,
   onEdit,
   onDuplicate,
-  onTest,
+  onTest: _onTest, // Hidden: stream check feature disabled
   onConfigureUsage,
   onDelete,
   onRemoveFromConfig,
@@ -58,14 +60,20 @@ export function ProviderActions({
   isAutoFailoverEnabled = false,
   isInFailoverQueue = false,
   onToggleFailover,
+  // OpenClaw: default model
+  isDefaultModel = false,
+  onSetAsDefault,
 }: ProviderActionsProps) {
   const { t } = useTranslation();
   const iconButtonClass = "h-8 w-8 p-1";
 
-  const isOpenCodeMode = appId === "opencode" && !isOmo;
+  // 累加模式应用（OpenCode 非 OMO 和 OpenClaw）
+  const isAdditiveMode =
+    (appId === "opencode" && !isOmo) || appId === "openclaw";
 
+  // 故障转移模式下的按钮逻辑（累加模式和 OMO 应用不支持故障转移）
   const isFailoverMode =
-    !isOpenCodeMode && !isOmo && isAutoFailoverEnabled && onToggleFailover;
+    !isAdditiveMode && !isOmo && isAutoFailoverEnabled && onToggleFailover;
 
   const handleMainButtonClick = () => {
     if (isOmo) {
@@ -74,7 +82,8 @@ export function ProviderActions({
       } else {
         onSwitch();
       }
-    } else if (isOpenCodeMode) {
+    } else if (isAdditiveMode) {
+      // 累加模式：切换配置状态（添加/移除）
       if (isInConfig) {
         if (onRemoveFromConfig) {
           onRemoveFromConfig();
@@ -112,13 +121,16 @@ export function ProviderActions({
       };
     }
 
-    if (isOpenCodeMode) {
+    // 累加模式（OpenCode 非 OMO / OpenClaw）
+    if (isAdditiveMode) {
       if (isInConfig) {
         return {
-          disabled: false,
+          disabled: isDefaultModel === true,
           variant: "secondary" as const,
-          className:
+          className: cn(
             "bg-orange-100 text-orange-600 hover:bg-orange-200 dark:bg-orange-900/50 dark:text-orange-400 dark:hover:bg-orange-900/70",
+            isDefaultModel && "opacity-40 cursor-not-allowed",
+          ),
           icon: <Minus className="h-4 w-4" />,
           text: t("provider.removeFromConfig", { defaultValue: "移除" }),
         };
@@ -178,14 +190,30 @@ export function ProviderActions({
 
   const buttonState = getMainButtonState();
 
-  const canDelete = isOmo
-    ? !(isLastOmo && isCurrent)
-    : isOpenCodeMode
-      ? true
-      : !isCurrent;
+  const canDelete = isOmo || isAdditiveMode ? true : !isCurrent;
 
   return (
     <div className="flex items-center gap-1.5">
+      {appId === "openclaw" && isInConfig && onSetAsDefault && (
+        <Button
+          size="sm"
+          variant={isDefaultModel ? "secondary" : "default"}
+          onClick={isDefaultModel ? undefined : onSetAsDefault}
+          disabled={isDefaultModel}
+          className={cn(
+            "w-fit px-2.5",
+            isDefaultModel
+              ? "bg-gray-200 text-muted-foreground dark:bg-gray-700 opacity-60 cursor-not-allowed"
+              : "bg-blue-500 hover:bg-blue-600 dark:bg-blue-600 dark:hover:bg-blue-700",
+          )}
+        >
+          <Zap className="h-4 w-4" />
+          {isDefaultModel
+            ? t("provider.isDefault", { defaultValue: "当前默认" })
+            : t("provider.setAsDefault", { defaultValue: "设为默认" })}
+        </Button>
+      )}
+
       <Button
         size="sm"
         variant={buttonState.variant}
@@ -218,6 +246,7 @@ export function ProviderActions({
           <Copy className="h-4 w-4" />
         </Button>
 
+        {/* Hidden: stream check feature disabled
         {onTest && (
           <Button
             size="icon"
@@ -234,6 +263,7 @@ export function ProviderActions({
             )}
           </Button>
         )}
+        */}
 
         <Button
           size="icon"

src/components/providers/ProviderCard.tsx

@@ -28,12 +28,13 @@ interface ProviderCardProps {
   appId: AppId;
   isInConfig?: boolean; // OpenCode: 是否已添加到 opencode.json
   isOmo?: boolean;
-  isLastOmo?: boolean;
+  isOmoSlim?: boolean;
   onSwitch: (provider: Provider) => void;
   onEdit: (provider: Provider) => void;
   onDelete: (provider: Provider) => void;
   onRemoveFromConfig?: (provider: Provider) => void;
   onDisableOmo?: () => void;
+  onDisableOmoSlim?: () => void;
   onConfigureUsage: (provider: Provider) => void;
   onOpenWebsite: (url: string) => void;
   onDuplicate: (provider: Provider) => void;
@@ -48,6 +49,9 @@ interface ProviderCardProps {
   isInFailoverQueue?: boolean; // 是否在故障转移队列中
   onToggleFailover?: (enabled: boolean) => void; // 切换故障转移队列
   activeProviderId?: string; // 代理当前实际使用的供应商 ID（用于故障转移模式下标注绿色边框）
+  // OpenClaw: default model
+  isDefaultModel?: boolean;
+  onSetAsDefault?: () => void;
 }
 
 const extractApiUrl = (provider: Provider, fallbackText: string) => {
@@ -88,12 +92,13 @@ export function ProviderCard({
   appId,
   isInConfig = true,
   isOmo = false,
-  isLastOmo = false,
+  isOmoSlim = false,
   onSwitch,
   onEdit,
   onDelete,
   onRemoveFromConfig,
   onDisableOmo,
+  onDisableOmoSlim,
   onConfigureUsage,
   onOpenWebsite,
   onDuplicate,
@@ -108,9 +113,16 @@ export function ProviderCard({
   isInFailoverQueue = false,
   onToggleFailover,
   activeProviderId,
+  // OpenClaw: default model
+  isDefaultModel,
+  onSetAsDefault,
 }: ProviderCardProps) {
   const { t } = useTranslation();
 
+  // OMO and OMO Slim share the same card behavior
+  const isAnyOmo = isOmo || isOmoSlim;
+  const handleDisableAnyOmo = isOmoSlim ? onDisableOmoSlim : onDisableOmo;
+
   const { data: health } = useProviderHealth(provider.id, appId);
 
   const fallbackUrlText = t("provider.notConfigured", {
@@ -133,7 +145,10 @@ export function ProviderCard({
 
   const usageEnabled = provider.meta?.usage_script?.enabled ?? false;
 
-  const shouldAutoQuery = appId === "opencode" ? isInConfig : isCurrent;
+  // 获取用量数据以判断是否有多套餐
+  // 累加模式应用（OpenCode/OpenClaw）：使用 isInConfig 代替 isCurrent
+  const shouldAutoQuery =
+    appId === "opencode" || appId === "openclaw" ? isInConfig : isCurrent;
   const autoQueryInterval = shouldAutoQuery
     ? provider.meta?.usage_script?.autoQueryInterval || 0
     : 0;
@@ -176,18 +191,23 @@ export function ProviderCard({
     onOpenWebsite(displayUrl);
   };
 
-  const isActiveProvider = isOmo
+  // 判断是否是"当前使用中"的供应商
+  // - OMO/OMO Slim 供应商：使用 isCurrent
+  // - 累加模式应用（OpenCode 非 OMO / OpenClaw）：不存在"当前"概念，始终返回 false
+  // - 故障转移模式：代理实际使用的供应商（activeProviderId）
+  // - 普通模式：isCurrent
+  const isActiveProvider = isAnyOmo
     ? isCurrent
-    : appId === "opencode"
+    : appId === "opencode" || appId === "openclaw"
       ? false
       : isAutoFailoverEnabled
         ? activeProviderId === provider.id
         : isCurrent;
 
-  const shouldUseGreen = !isOmo && isProxyTakeover && isActiveProvider;
+  const shouldUseGreen = !isAnyOmo && isProxyTakeover && isActiveProvider;
   const shouldUseBlue =
-    (isOmo && isActiveProvider) ||
-    (!isOmo && !isProxyTakeover && isActiveProvider);
+    (isAnyOmo && isActiveProvider) ||
+    (!isAnyOmo && !isProxyTakeover && isActiveProvider);
 
   return (
     <div
@@ -251,6 +271,12 @@ export function ProviderCard({
                 </span>
               )}
 
+              {isOmoSlim && (
+                <span className="inline-flex items-center rounded-md bg-indigo-100 px-1.5 py-0.5 text-[10px] font-semibold text-indigo-700 dark:bg-indigo-900/40 dark:text-indigo-300">
+                  Slim
+                </span>
+              )}
+
               {isProxyRunning && isInFailoverQueue && health && (
                 <ProviderHealthBadge
                   consecutiveFailures={health.consecutive_failures}
@@ -358,8 +384,7 @@ export function ProviderCard({
               isInConfig={isInConfig}
               isTesting={isTesting}
               isProxyTakeover={isProxyTakeover}
-              isOmo={isOmo}
-              isLastOmo={isLastOmo}
+              isOmo={isAnyOmo}
               onSwitch={() => onSwitch(provider)}
               onEdit={() => onEdit(provider)}
               onDuplicate={() => onDuplicate(provider)}
@@ -371,13 +396,16 @@ export function ProviderCard({
                   ? () => onRemoveFromConfig(provider)
                   : undefined
               }
-              onDisableOmo={onDisableOmo}
+              onDisableOmo={handleDisableAnyOmo}
               onOpenTerminal={
                 onOpenTerminal ? () => onOpenTerminal(provider) : undefined
               }
               isAutoFailoverEnabled={isAutoFailoverEnabled}
               isInFailoverQueue={isInFailoverQueue}
               onToggleFailover={onToggleFailover}
+              // OpenClaw: default model
+              isDefaultModel={isDefaultModel}
+              onSetAsDefault={onSetAsDefault}
             />
           </div>
         </div>

src/components/providers/ProviderEmptyState.tsx

@@ -1,12 +1,16 @@
-import { Users } from "lucide-react";
+import { Download, Users } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { Button } from "@/components/ui/button";
 
 interface ProviderEmptyStateProps {
   onCreate?: () => void;
+  onImport?: () => void;
 }
 
-export function ProviderEmptyState({ onCreate }: ProviderEmptyStateProps) {
+export function ProviderEmptyState({
+  onCreate,
+  onImport,
+}: ProviderEmptyStateProps) {
   const { t } = useTranslation();
 
   return (
@@ -18,11 +22,19 @@ export function ProviderEmptyState({ onCreate }: ProviderEmptyStateProps) {
       <p className="mt-2 max-w-sm text-sm text-muted-foreground">
         {t("provider.noProvidersDescription")}
       </p>
-      {onCreate && (
-        <Button className="mt-6" onClick={onCreate}>
-          {t("provider.addProvider")}
-        </Button>
-      )}
+      <div className="mt-6 flex flex-col gap-2">
+        {onImport && (
+          <Button onClick={onImport}>
+            <Download className="mr-2 h-4 w-4" />
+            {t("provider.importCurrent")}
+          </Button>
+        )}
+        {onCreate && (
+          <Button variant={onImport ? "outline" : "default"} onClick={onCreate}>
+            {t("provider.addProvider")}
+          </Button>
+        )}
+      </div>
     </div>
   );
 }

src/components/providers/ProviderList.tsx

@@ -15,11 +15,17 @@ import {
 import { AnimatePresence, motion } from "framer-motion";
 import { Search, X } from "lucide-react";
 import { useTranslation } from "react-i18next";
-import { useQuery } from "@tanstack/react-query";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
 import type { Provider } from "@/types";
 import type { AppId } from "@/lib/api";
 import { providersApi } from "@/lib/api/providers";
 import { useDragSort } from "@/hooks/useDragSort";
+import {
+  useOpenClawLiveProviderIds,
+  useOpenClawDefaultModel,
+} from "@/hooks/useOpenClaw";
+// import { useStreamCheck } from "@/hooks/useStreamCheck"; // 测试功能已隐藏
 import { ProviderCard } from "@/components/providers/ProviderCard";
 import { ProviderEmptyState } from "@/components/providers/ProviderEmptyState";
 import {
@@ -28,7 +34,10 @@ import {
   useAddToFailoverQueue,
   useRemoveFromFailoverQueue,
 } from "@/lib/query/failover";
-import { useCurrentOmoProviderId, useOmoProviderCount } from "@/lib/query/omo";
+import {
+  useCurrentOmoProviderId,
+  useCurrentOmoSlimProviderId,
+} from "@/lib/query/omo";
 import { useCallback } from "react";
 import { Input } from "@/components/ui/input";
 import { Button } from "@/components/ui/button";
@@ -42,6 +51,7 @@ interface ProviderListProps {
   onDelete: (provider: Provider) => void;
   onRemoveFromConfig?: (provider: Provider) => void;
   onDisableOmo?: () => void;
+  onDisableOmoSlim?: () => void;
   onDuplicate: (provider: Provider) => void;
   onConfigureUsage?: (provider: Provider) => void;
   onOpenWebsite: (url: string) => void;
@@ -51,6 +61,7 @@ interface ProviderListProps {
   isProxyRunning?: boolean; // 代理服务运行状态
   isProxyTakeover?: boolean; // 代理接管模式（Live配置已被接管）
   activeProviderId?: string; // 代理当前实际使用的供应商 ID（用于故障转移模式下标注绿色边框）
+  onSetAsDefault?: (provider: Provider) => void; // OpenClaw: set as default model
 }
 
 export function ProviderList({
@@ -62,6 +73,7 @@ export function ProviderList({
   onDelete,
   onRemoveFromConfig,
   onDisableOmo,
+  onDisableOmoSlim,
   onDuplicate,
   onConfigureUsage,
   onOpenWebsite,
@@ -71,6 +83,7 @@ export function ProviderList({
   isProxyRunning = false,
   isProxyTakeover = false,
   activeProviderId,
+  onSetAsDefault,
 }: ProviderListProps) {
   const { t } = useTranslation();
   const { sortedProviders, sensors, handleDragEnd } = useDragSort(
@@ -84,14 +97,39 @@ export function ProviderList({
     enabled: appId === "opencode",
   });
 
-  const isProviderInConfig = useCallback(
-    (providerId: string): boolean => {
-      if (appId !== "opencode") return true; // 非 OpenCode 应用始终返回 true
-      return opencodeLiveIds?.includes(providerId) ?? false;
-    },
-    [appId, opencodeLiveIds],
+  // OpenClaw: 查询 live 配置中的供应商 ID 列表，用于判断 isInConfig
+  const { data: openclawLiveIds } = useOpenClawLiveProviderIds(
+    appId === "openclaw",
   );
 
+  // 判断供应商是否已添加到配置（累加模式应用：OpenCode/OpenClaw）
+  const isProviderInConfig = useCallback(
+    (providerId: string): boolean => {
+      if (appId === "opencode") {
+        return opencodeLiveIds?.includes(providerId) ?? false;
+      }
+      if (appId === "openclaw") {
+        return openclawLiveIds?.includes(providerId) ?? false;
+      }
+      return true; // 其他应用始终返回 true
+    },
+    [appId, opencodeLiveIds, openclawLiveIds],
+  );
+
+  // OpenClaw: query default model to determine which provider is default
+  const { data: openclawDefaultModel } = useOpenClawDefaultModel(
+    appId === "openclaw",
+  );
+
+  const isProviderDefaultModel = useCallback(
+    (providerId: string): boolean => {
+      if (appId !== "openclaw" || !openclawDefaultModel?.primary) return false;
+      return openclawDefaultModel.primary.startsWith(providerId + "/");
+    },
+    [appId, openclawDefaultModel],
+  );
+
+  // 故障转移相关
   const { data: isAutoFailoverEnabled } = useAutoFailoverEnabled(appId);
   const { data: failoverQueue } = useFailoverQueue(appId);
   const addToQueue = useAddToFailoverQueue();
@@ -102,7 +140,7 @@ export function ProviderList({
 
   const isOpenCode = appId === "opencode";
   const { data: currentOmoId } = useCurrentOmoProviderId(isOpenCode);
-  const { data: omoProviderCount } = useOmoProviderCount(isOpenCode);
+  const { data: currentOmoSlimId } = useCurrentOmoSlimProviderId(isOpenCode);
 
   const getFailoverPriority = useCallback(
     (providerId: string): number | undefined => {
@@ -138,6 +176,33 @@ export function ProviderList({
   const [isSearchOpen, setIsSearchOpen] = useState(false);
   const searchInputRef = useRef<HTMLInputElement>(null);
 
+  // Import current live config as default provider
+  const queryClient = useQueryClient();
+  const importMutation = useMutation({
+    mutationFn: async (): Promise<boolean> => {
+      if (appId === "opencode") {
+        const count = await providersApi.importOpenCodeFromLive();
+        return count > 0;
+      }
+      if (appId === "openclaw") {
+        const count = await providersApi.importOpenClawFromLive();
+        return count > 0;
+      }
+      return providersApi.importDefault(appId);
+    },
+    onSuccess: (imported) => {
+      if (imported) {
+        queryClient.invalidateQueries({ queryKey: ["providers", appId] });
+        toast.success(t("provider.importCurrentDescription"));
+      } else {
+        toast.info(t("provider.noProviders"));
+      }
+    },
+    onError: (error: Error) => {
+      toast.error(error.message);
+    },
+  });
+
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {
       const key = event.key.toLowerCase();
@@ -191,7 +256,12 @@ export function ProviderList({
   }
 
   if (sortedProviders.length === 0) {
-    return <ProviderEmptyState onCreate={onCreate} />;
+    return (
+      <ProviderEmptyState
+        onCreate={onCreate}
+        onImport={() => importMutation.mutate()}
+      />
+    );
   }
 
   const renderProviderList = () => (
@@ -207,25 +277,31 @@ export function ProviderList({
         <div className="space-y-3">
           {filteredProviders.map((provider) => {
             const isOmo = provider.category === "omo";
+            const isOmoSlim = provider.category === "omo-slim";
             const isOmoCurrent = isOmo && provider.id === (currentOmoId || "");
+            const isOmoSlimCurrent =
+              isOmoSlim && provider.id === (currentOmoSlimId || "");
             return (
               <SortableProviderCard
                 key={provider.id}
                 provider={provider}
                 isCurrent={
-                  isOmo ? isOmoCurrent : provider.id === currentProviderId
+                  isOmo
+                    ? isOmoCurrent
+                    : isOmoSlim
+                      ? isOmoSlimCurrent
+                      : provider.id === currentProviderId
                 }
                 appId={appId}
                 isInConfig={isProviderInConfig(provider.id)}
                 isOmo={isOmo}
-                isLastOmo={
-                  isOmo && (omoProviderCount ?? 0) <= 1 && isOmoCurrent
-                }
+                isOmoSlim={isOmoSlim}
                 onSwitch={onSwitch}
                 onEdit={onEdit}
                 onDelete={onDelete}
                 onRemoveFromConfig={onRemoveFromConfig}
                 onDisableOmo={onDisableOmo}
+                onDisableOmoSlim={onDisableOmoSlim}
                 onDuplicate={onDuplicate}
                 onConfigureUsage={onConfigureUsage}
                 onOpenWebsite={onOpenWebsite}
@@ -240,6 +316,11 @@ export function ProviderList({
                   handleToggleFailover(provider.id, enabled)
                 }
                 activeProviderId={activeProviderId}
+                // OpenClaw: default model
+                isDefaultModel={isProviderDefaultModel(provider.id)}
+                onSetAsDefault={
+                  onSetAsDefault ? () => onSetAsDefault(provider) : undefined
+                }
               />
             );
           })}
@@ -333,12 +414,13 @@ interface SortableProviderCardProps {
   appId: AppId;
   isInConfig: boolean;
   isOmo: boolean;
-  isLastOmo: boolean;
+  isOmoSlim: boolean;
   onSwitch: (provider: Provider) => void;
   onEdit: (provider: Provider) => void;
   onDelete: (provider: Provider) => void;
   onRemoveFromConfig?: (provider: Provider) => void;
   onDisableOmo?: () => void;
+  onDisableOmoSlim?: () => void;
   onDuplicate: (provider: Provider) => void;
   onConfigureUsage?: (provider: Provider) => void;
   onOpenWebsite: (url: string) => void;
@@ -352,6 +434,9 @@ interface SortableProviderCardProps {
   isInFailoverQueue: boolean;
   onToggleFailover: (enabled: boolean) => void;
   activeProviderId?: string;
+  // OpenClaw: default model
+  isDefaultModel?: boolean;
+  onSetAsDefault?: () => void;
 }
 
 function SortableProviderCard({
@@ -360,12 +445,13 @@ function SortableProviderCard({
   appId,
   isInConfig,
   isOmo,
-  isLastOmo,
+  isOmoSlim,
   onSwitch,
   onEdit,
   onDelete,
   onRemoveFromConfig,
   onDisableOmo,
+  onDisableOmoSlim,
   onDuplicate,
   onConfigureUsage,
   onOpenWebsite,
@@ -379,6 +465,8 @@ function SortableProviderCard({
   isInFailoverQueue,
   onToggleFailover,
   activeProviderId,
+  isDefaultModel,
+  onSetAsDefault,
 }: SortableProviderCardProps) {
   const {
     setNodeRef,
@@ -402,12 +490,13 @@ function SortableProviderCard({
         appId={appId}
         isInConfig={isInConfig}
         isOmo={isOmo}
-        isLastOmo={isLastOmo}
+        isOmoSlim={isOmoSlim}
         onSwitch={onSwitch}
         onEdit={onEdit}
         onDelete={onDelete}
         onRemoveFromConfig={onRemoveFromConfig}
         onDisableOmo={onDisableOmo}
+        onDisableOmoSlim={onDisableOmoSlim}
         onDuplicate={onDuplicate}
         onConfigureUsage={
           onConfigureUsage ? (item) => onConfigureUsage(item) : () => undefined
@@ -428,6 +517,9 @@ function SortableProviderCard({
         isInFailoverQueue={isInFailoverQueue}
         onToggleFailover={onToggleFailover}
         activeProviderId={activeProviderId}
+        // OpenClaw: default model
+        isDefaultModel={isDefaultModel}
+        onSetAsDefault={onSetAsDefault}
       />
     </div>
   );

src/components/providers/forms/ClaudeFormFields.tsx

@@ -188,8 +188,8 @@ export function ClaudeFormFields({
         />
       )}
 
-      {/* API 格式选择（仅非官方供应商显示） */}
-      {shouldShowModelSelector && (
+      {/* API 格式选择（仅非官方、非云服务商显示） */}
+      {shouldShowModelSelector && category !== "cloud_provider" && (
         <div className="space-y-2">
           <FormLabel htmlFor="apiFormat">
             {t("providerForm.apiFormat", { defaultValue: "API 格式" })}

src/components/providers/forms/CommonConfigEditor.tsx

@@ -1,5 +1,5 @@
 import { useTranslation } from "react-i18next";
-import { useEffect, useState } from "react";
+import { useEffect, useState, useCallback, useMemo } from "react";
 import { FullScreenPanel } from "@/components/common/FullScreenPanel";
 import { Label } from "@/components/ui/label";
 import { Button } from "@/components/ui/button";
@@ -53,6 +53,81 @@ export function CommonConfigEditor({
     return () => observer.disconnect();
   }, []);
 
+  // Mirror value prop to local state so checkbox toggles and JsonEditor stay in sync
+  // (parent uses form.getValues which doesn't trigger re-renders)
+  const [localValue, setLocalValue] = useState(value);
+
+  useEffect(() => {
+    setLocalValue(value);
+  }, [value]);
+
+  const handleLocalChange = useCallback(
+    (newValue: string) => {
+      setLocalValue(newValue);
+      onChange(newValue);
+    },
+    [onChange],
+  );
+
+  const toggleStates = useMemo(() => {
+    try {
+      const config = JSON.parse(localValue);
+      return {
+        hideAttribution:
+          config?.attribution?.commit === "" && config?.attribution?.pr === "",
+        alwaysThinking: config?.alwaysThinkingEnabled === true,
+        teammates:
+          config?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1" ||
+          config?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === 1,
+      };
+    } catch {
+      return {
+        hideAttribution: false,
+        alwaysThinking: false,
+        teammates: false,
+      };
+    }
+  }, [localValue]);
+
+  const handleToggle = useCallback(
+    (toggleKey: string, checked: boolean) => {
+      try {
+        const config = JSON.parse(localValue || "{}");
+
+        switch (toggleKey) {
+          case "hideAttribution":
+            if (checked) {
+              config.attribution = { commit: "", pr: "" };
+            } else {
+              delete config.attribution;
+            }
+            break;
+          case "alwaysThinking":
+            if (checked) {
+              config.alwaysThinkingEnabled = true;
+            } else {
+              delete config.alwaysThinkingEnabled;
+            }
+            break;
+          case "teammates":
+            if (!config.env) config.env = {};
+            if (checked) {
+              config.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
+            } else {
+              delete config.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+              if (Object.keys(config.env).length === 0) delete config.env;
+            }
+            break;
+        }
+
+        handleLocalChange(JSON.stringify(config, null, 2));
+      } catch {
+        // Don't modify if JSON is invalid
+      }
+    },
+    [localValue, handleLocalChange],
+  );
+
   return (
     <>
       <div className="space-y-2">
@@ -91,9 +166,40 @@ export function CommonConfigEditor({
             {commonConfigError}
           </p>
         )}
+        <div className="flex flex-wrap items-center gap-x-4 gap-y-1">
+          <label className="inline-flex items-center gap-2 text-sm text-muted-foreground cursor-pointer">
+            <input
+              type="checkbox"
+              checked={toggleStates.hideAttribution}
+              onChange={(e) =>
+                handleToggle("hideAttribution", e.target.checked)
+              }
+              className="w-4 h-4 text-blue-500 bg-white dark:bg-gray-800 border-border-default rounded focus:ring-blue-500 dark:focus:ring-blue-400 focus:ring-2"
+            />
+            <span>{t("claudeConfig.hideAttribution")}</span>
+          </label>
+          <label className="inline-flex items-center gap-2 text-sm text-muted-foreground cursor-pointer">
+            <input
+              type="checkbox"
+              checked={toggleStates.alwaysThinking}
+              onChange={(e) => handleToggle("alwaysThinking", e.target.checked)}
+              className="w-4 h-4 text-blue-500 bg-white dark:bg-gray-800 border-border-default rounded focus:ring-blue-500 dark:focus:ring-blue-400 focus:ring-2"
+            />
+            <span>{t("claudeConfig.alwaysThinking")}</span>
+          </label>
+          <label className="inline-flex items-center gap-2 text-sm text-muted-foreground cursor-pointer">
+            <input
+              type="checkbox"
+              checked={toggleStates.teammates}
+              onChange={(e) => handleToggle("teammates", e.target.checked)}
+              className="w-4 h-4 text-blue-500 bg-white dark:bg-gray-800 border-border-default rounded focus:ring-blue-500 dark:focus:ring-blue-400 focus:ring-2"
+            />
+            <span>{t("claudeConfig.enableTeammates")}</span>
+          </label>
+        </div>
         <JsonEditor
-          value={value}
-          onChange={onChange}
+          value={localValue}
+          onChange={handleLocalChange}
           placeholder={`{
   "env": {
     "ANTHROPIC_BASE_URL": "https://your-api-endpoint.com",

src/components/providers/forms/EndpointSpeedTest.tsx

@@ -14,6 +14,7 @@ const ENDPOINT_TIMEOUT_SECS: Record<AppId, number> = {
   claude: 8,
   gemini: 8,
   opencode: 8,
+  openclaw: 8,
 };
 
 interface TestResult {

src/components/providers/forms/OmoCommonConfigEditor.tsx

@@ -1,161 +0,0 @@
-import { useTranslation } from "react-i18next";
-import { useEffect, useState } from "react";
-import { FullScreenPanel } from "@/components/common/FullScreenPanel";
-import { Label } from "@/components/ui/label";
-import { Button } from "@/components/ui/button";
-import { Save, FolderInput, Loader2 } from "lucide-react";
-import JsonEditor from "@/components/JsonEditor";
-import {
-  OmoGlobalConfigFields,
-  type OmoGlobalConfigFieldsRef,
-} from "./OmoGlobalConfigFields";
-import type { OmoGlobalConfig } from "@/types/omo";
-
-interface OmoCommonConfigEditorProps {
-  previewValue: string;
-  useCommonConfig: boolean;
-  onCommonConfigToggle: (checked: boolean) => void;
-  isModalOpen: boolean;
-  onEditClick: () => void;
-  onModalClose: () => void;
-  onSave: () => Promise<void>;
-  isSaving: boolean;
-  onGlobalConfigStateChange: (config: OmoGlobalConfig) => void;
-  globalConfigRef: React.RefObject<OmoGlobalConfigFieldsRef | null>;
-  fieldsKey: number;
-}
-
-export function OmoCommonConfigEditor({
-  previewValue,
-  useCommonConfig,
-  onCommonConfigToggle,
-  isModalOpen,
-  onEditClick,
-  onModalClose,
-  onSave,
-  isSaving,
-  onGlobalConfigStateChange,
-  globalConfigRef,
-  fieldsKey,
-}: OmoCommonConfigEditorProps) {
-  const { t } = useTranslation();
-  const [isDarkMode, setIsDarkMode] = useState(false);
-  const [isImporting, setIsImporting] = useState(false);
-  useEffect(() => {
-    const syncDarkMode = () =>
-      setIsDarkMode(document.documentElement.classList.contains("dark"));
-    syncDarkMode();
-    const observer = new MutationObserver(syncDarkMode);
-    observer.observe(document.documentElement, {
-      attributes: true,
-      attributeFilter: ["class"],
-    });
-    return () => observer.disconnect();
-  }, []);
-  const handleImportLocal = async () => {
-    if (!globalConfigRef.current) return;
-    setIsImporting(true);
-    try {
-      await globalConfigRef.current.importFromLocal();
-    } finally {
-      setIsImporting(false);
-    }
-  };
-  return (
-    <>
-      <div className="space-y-2">
-        <div className="flex items-center justify-between">
-          <Label>{t("provider.configJson")}</Label>
-          <div className="flex items-center gap-2">
-            <label className="inline-flex items-center gap-2 text-sm text-muted-foreground cursor-pointer">
-              <input
-                type="checkbox"
-                checked={useCommonConfig}
-                onChange={(e) => onCommonConfigToggle(e.target.checked)}
-                className="w-4 h-4 text-blue-500 bg-white dark:bg-gray-800 border-border-default rounded focus:ring-blue-500 dark:focus:ring-blue-400 focus:ring-2"
-              />
-              <span>
-                {t("omo.writeCommonConfig", {
-                  defaultValue: "Write to common config",
-                })}
-              </span>
-            </label>
-          </div>
-        </div>
-        <div className="flex items-center justify-end">
-          <button
-            type="button"
-            onClick={onEditClick}
-            className="text-xs text-blue-400 dark:text-blue-500 hover:text-blue-500 dark:hover:text-blue-400 transition-colors"
-          >
-            {t("omo.editCommonConfig", { defaultValue: "Edit common config" })}
-          </button>
-        </div>
-        <JsonEditor
-          value={previewValue}
-          onChange={() => {}}
-          darkMode={isDarkMode}
-          rows={14}
-          showValidation={false}
-          language="json"
-        />
-      </div>
-      <FullScreenPanel
-        isOpen={isModalOpen}
-        title={t("omo.editCommonConfigTitle", {
-          defaultValue: "Edit OMO Common Config",
-        })}
-        onClose={onModalClose}
-        footer={
-          <>
-            <Button
-              type="button"
-              variant="outline"
-              onClick={handleImportLocal}
-              disabled={isImporting}
-              className="gap-2"
-            >
-              {isImporting ? (
-                <Loader2 className="w-4 h-4 animate-spin" />
-              ) : (
-                <FolderInput className="w-4 h-4" />
-              )}
-              {t("common.import", { defaultValue: "Import" })}
-            </Button>
-            <Button type="button" variant="outline" onClick={onModalClose}>
-              {t("common.cancel")}
-            </Button>
-            <Button
-              type="button"
-              onClick={onSave}
-              disabled={isSaving}
-              className="gap-2"
-            >
-              {isSaving ? (
-                <Loader2 className="w-4 h-4 animate-spin" />
-              ) : (
-                <Save className="w-4 h-4" />
-              )}
-              {t("common.save")}
-            </Button>
-          </>
-        }
-      >
-        <div className="space-y-4">
-          <p className="text-sm text-muted-foreground">
-            {t("omo.commonConfigHint", {
-              defaultValue:
-                "OMO common config will be merged into all OMO configs that enable it",
-            })}
-          </p>
-          <OmoGlobalConfigFields
-            key={fieldsKey}
-            ref={globalConfigRef as React.Ref<OmoGlobalConfigFieldsRef>}
-            onStateChange={onGlobalConfigStateChange}
-            hideSaveButtons
-          />
-        </div>
-      </FullScreenPanel>
-    </>
-  );
-}

src/components/providers/forms/OmoFormFields.tsx

@@ -41,10 +41,11 @@ import {
 } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { toast } from "sonner";
-import { useReadOmoLocalFile } from "@/lib/query/omo";
+import { useReadOmoLocalFile, useReadOmoSlimLocalFile } from "@/lib/query/omo";
 import {
   OMO_BUILTIN_AGENTS,
   OMO_BUILTIN_CATEGORIES,
+  OMO_SLIM_BUILTIN_AGENTS,
   type OmoAgentDef,
   type OmoCategoryDef,
 } from "@/types/omo";
@@ -69,12 +70,13 @@ interface OmoFormFieldsProps {
   >;
   agents: Record<string, Record<string, unknown>>;
   onAgentsChange: (agents: Record<string, Record<string, unknown>>) => void;
-  categories: Record<string, Record<string, unknown>>;
-  onCategoriesChange: (
+  categories?: Record<string, Record<string, unknown>>;
+  onCategoriesChange?: (
     categories: Record<string, Record<string, unknown>>,
   ) => void;
   otherFieldsStr: string;
   onOtherFieldsStrChange: (value: string) => void;
+  isSlim?: boolean;
 }
 
 export type CustomModelItem = {
@@ -121,6 +123,9 @@ function DeferredKeyInput({
 }
 
 const BUILTIN_AGENT_KEYS = new Set(OMO_BUILTIN_AGENTS.map((a) => a.key));
+const BUILTIN_AGENT_KEYS_SLIM = new Set(
+  OMO_SLIM_BUILTIN_AGENTS.map((a) => a.key),
+);
 const BUILTIN_CATEGORY_KEYS = new Set(OMO_BUILTIN_CATEGORIES.map((c) => c.key));
 const EMPTY_VARIANT_VALUE = "__cc_switch_omo_variant_empty__";
 
@@ -303,13 +308,21 @@ export function OmoFormFields({
   presetMetaMap: _presetMetaMap = {},
   agents,
   onAgentsChange,
-  categories,
+  categories = {},
   onCategoriesChange,
   otherFieldsStr,
   onOtherFieldsStrChange,
+  isSlim = false,
 }: OmoFormFieldsProps) {
   const { t } = useTranslation();
 
+  const builtinAgentDefs = isSlim
+    ? OMO_SLIM_BUILTIN_AGENTS
+    : OMO_BUILTIN_AGENTS;
+  const builtinAgentKeys = isSlim
+    ? BUILTIN_AGENT_KEYS_SLIM
+    : BUILTIN_AGENT_KEYS;
+
   const [mainAgentsOpen, setMainAgentsOpen] = useState(true);
   const [subAgentsOpen, setSubAgentsOpen] = useState(true);
   const [categoriesOpen, setCategoriesOpen] = useState(true);
@@ -329,7 +342,7 @@ export function OmoFormFields({
   >({});
 
   const [customAgents, setCustomAgents] = useState<CustomModelItem[]>(() =>
-    collectCustomModels(agents, BUILTIN_AGENT_KEYS),
+    collectCustomModels(agents, builtinAgentKeys),
   );
 
   const [customCategories, setCustomCategories] = useState<CustomModelItem[]>(
@@ -337,7 +350,7 @@ export function OmoFormFields({
   );
 
   useEffect(() => {
-    setCustomAgents(collectCustomModels(agents, BUILTIN_AGENT_KEYS));
+    setCustomAgents(collectCustomModels(agents, builtinAgentKeys));
   }, [agents]);
 
   useEffect(() => {
@@ -349,17 +362,18 @@ export function OmoFormFields({
       onAgentsChange(
         mergeCustomModelsIntoStore(
           agents,
-          BUILTIN_AGENT_KEYS,
+          builtinAgentKeys,
           customs,
           modelVariantsMap,
         ),
       );
     },
-    [agents, onAgentsChange, modelVariantsMap],
+    [agents, onAgentsChange, modelVariantsMap, builtinAgentKeys],
   );
 
   const syncCustomCategories = useCallback(
     (customs: CustomModelItem[]) => {
+      if (!onCategoriesChange) return;
       onCategoriesChange(
         mergeCustomModelsIntoStore(
           categories,
@@ -708,42 +722,91 @@ export function OmoFormFields({
       return;
     }
 
+    let filledCount = 0;
+    let alreadySetCount = 0;
+    let unmatchedCount = 0;
+
     const updatedAgents = { ...agents };
-    for (const agentDef of OMO_BUILTIN_AGENTS) {
+    for (const agentDef of builtinAgentDefs) {
       const recommendedValue = resolveRecommendedModel(agentDef.recommended);
-      if (recommendedValue && !updatedAgents[agentDef.key]?.model) {
+      if (!recommendedValue) {
+        unmatchedCount++;
+      } else if (updatedAgents[agentDef.key]?.model) {
+        alreadySetCount++;
+      } else {
         updatedAgents[agentDef.key] = {
           ...updatedAgents[agentDef.key],
           model: recommendedValue,
         };
+        filledCount++;
       }
     }
     onAgentsChange(updatedAgents);
 
-    const updatedCategories = { ...categories };
-    for (const catDef of OMO_BUILTIN_CATEGORIES) {
-      const recommendedValue = resolveRecommendedModel(catDef.recommended);
-      if (recommendedValue && !updatedCategories[catDef.key]?.model) {
-        updatedCategories[catDef.key] = {
-          ...updatedCategories[catDef.key],
-          model: recommendedValue,
-        };
+    if (!isSlim && onCategoriesChange) {
+      const updatedCategories = { ...categories };
+      for (const catDef of OMO_BUILTIN_CATEGORIES) {
+        const recommendedValue = resolveRecommendedModel(catDef.recommended);
+        if (!recommendedValue) {
+          unmatchedCount++;
+        } else if (updatedCategories[catDef.key]?.model) {
+          alreadySetCount++;
+        } else {
+          updatedCategories[catDef.key] = {
+            ...updatedCategories[catDef.key],
+            model: recommendedValue,
+          };
+          filledCount++;
+        }
       }
+      onCategoriesChange(updatedCategories);
+    }
+
+    if (filledCount > 0 && unmatchedCount === 0) {
+      toast.success(
+        t("omo.fillRecommendedSuccess", {
+          defaultValue: "Filled {{count}} recommended models",
+          count: filledCount,
+        }),
+      );
+    } else if (filledCount > 0 && unmatchedCount > 0) {
+      toast.success(
+        t("omo.fillRecommendedPartial", {
+          defaultValue:
+            "Filled {{filled}} recommended models, {{unmatched}} unmatched",
+          filled: filledCount,
+          unmatched: unmatchedCount,
+        }),
+      );
+    } else if (alreadySetCount > 0 && unmatchedCount === 0) {
+      toast.info(
+        t("omo.fillRecommendedAllSet", {
+          defaultValue: "All slots already have models configured",
+        }),
+      );
+    } else {
+      toast.warning(
+        t("omo.fillRecommendedNoMatch", {
+          defaultValue: "Recommended models not found in configured providers",
+        }),
+      );
     }
-    onCategoriesChange(updatedCategories);
   };
 
   const configuredAgentCount = Object.keys(agents).length;
-  const configuredCategoryCount = Object.keys(categories).length;
-  const mainAgents = OMO_BUILTIN_AGENTS.filter((a) => a.group === "main");
-  const subAgents = OMO_BUILTIN_AGENTS.filter((a) => a.group === "sub");
+  const configuredCategoryCount = isSlim ? 0 : Object.keys(categories).length;
+  const mainAgents = builtinAgentDefs.filter((a) => a.group === "main");
+  const subAgents = builtinAgentDefs.filter((a) => a.group === "sub");
 
   const readLocalFile = useReadOmoLocalFile();
+  const readSlimLocalFile = useReadOmoSlimLocalFile();
   const [localFilePath, setLocalFilePath] = useState<string | null>(null);
 
   const handleImportFromLocal = useCallback(async () => {
     try {
-      const data = await readLocalFile.mutateAsync();
+      const data = isSlim
+        ? await readSlimLocalFile.mutateAsync()
+        : await readLocalFile.mutateAsync();
       const importedAgents =
         (data.agents as Record<string, Record<string, unknown>> | undefined) ||
         {};
@@ -753,16 +816,20 @@ export function OmoFormFields({
           | undefined) || {};
 
       onAgentsChange(importedAgents);
-      onCategoriesChange(importedCategories);
+      if (!isSlim && onCategoriesChange) {
+        onCategoriesChange(importedCategories);
+      }
       onOtherFieldsStrChange(
         data.otherFields ? JSON.stringify(data.otherFields, null, 2) : "",
       );
       setAgentAdvancedDrafts({});
       setCategoryAdvancedDrafts({});
-      setCustomAgents(collectCustomModels(importedAgents, BUILTIN_AGENT_KEYS));
-      setCustomCategories(
-        collectCustomModels(importedCategories, BUILTIN_CATEGORY_KEYS),
-      );
+      setCustomAgents(collectCustomModels(importedAgents, builtinAgentKeys));
+      if (!isSlim) {
+        setCustomCategories(
+          collectCustomModels(importedCategories, BUILTIN_CATEGORY_KEYS),
+        );
+      }
       setLocalFilePath(data.filePath);
       toast.success(
         t("omo.importLocalReplaceSuccess", {
@@ -792,7 +859,7 @@ export function OmoFormFields({
   ) => {
     const isAgent = scope === "agent";
     const store = isAgent ? agents : categories;
-    const setter = isAgent ? onAgentsChange : onCategoriesChange;
+    const setter = isAgent ? onAgentsChange : onCategoriesChange!;
     const drafts = isAgent ? agentAdvancedDrafts : categoryAdvancedDrafts;
     const expanded = isAgent ? expandedAgents : expandedCategories;
 
@@ -866,7 +933,7 @@ export function OmoFormFields({
   ) => {
     const isAgent = scope === "agent";
     const store = isAgent ? agents : categories;
-    const setter = isAgent ? onAgentsChange : onCategoriesChange;
+    const setter = isAgent ? onAgentsChange : onCategoriesChange!;
     const drafts = isAgent ? agentAdvancedDrafts : categoryAdvancedDrafts;
     const expanded = isAgent ? expandedAgents : expandedCategories;
     const customs = isAgent ? customAgents : customCategories;
@@ -1153,30 +1220,31 @@ export function OmoFormFields({
         ),
       })}
 
-      {renderModelSection({
-        title: t("omo.categories", { defaultValue: "Categories" }),
-        isOpen: categoriesOpen,
-        onToggle: () => setCategoriesOpen(!categoriesOpen),
-        badge: `${OMO_BUILTIN_CATEGORIES.length + customCategories.length}`,
-        action: renderCustomAddButton(() => addCustomModel("category")),
-        children: (
-          <>
-            {OMO_BUILTIN_CATEGORIES.map(renderCategoryRow)}
-            {customCategories.length > 0 && (
-              <>
-                {renderCustomDivider(
-                  t("omo.customCategories", {
-                    defaultValue: "Custom Categories",
-                  }),
-                )}
-                {customCategories.map((c, i) =>
-                  renderCustomModelRow("category", c, i),
-                )}
-              </>
-            )}
-          </>
-        ),
-      })}
+      {!isSlim &&
+        renderModelSection({
+          title: t("omo.categories", { defaultValue: "Categories" }),
+          isOpen: categoriesOpen,
+          onToggle: () => setCategoriesOpen(!categoriesOpen),
+          badge: `${OMO_BUILTIN_CATEGORIES.length + customCategories.length}`,
+          action: renderCustomAddButton(() => addCustomModel("category")),
+          children: (
+            <>
+              {OMO_BUILTIN_CATEGORIES.map(renderCategoryRow)}
+              {customCategories.length > 0 && (
+                <>
+                  {renderCustomDivider(
+                    t("omo.customCategories", {
+                      defaultValue: "Custom Categories",
+                    }),
+                  )}
+                  {customCategories.map((c, i) =>
+                    renderCustomModelRow("category", c, i),
+                  )}
+                </>
+              )}
+            </>
+          ),
+        })}
 
       {renderModelSection({
         title: t("omo.otherFieldsJson", {

src/components/providers/forms/OmoGlobalConfigFields.tsx

@@ -1,739 +0,0 @@
-import {
-  useState,
-  useEffect,
-  useCallback,
-  forwardRef,
-  useImperativeHandle,
-} from "react";
-import { useTranslation } from "react-i18next";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Textarea } from "@/components/ui/textarea";
-import {
-  DropdownMenu,
-  DropdownMenuCheckboxItem,
-  DropdownMenuContent,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-import {
-  Save,
-  Loader2,
-  X,
-  FolderInput,
-  RotateCcw,
-  ChevronsUpDown,
-} from "lucide-react";
-import { cn } from "@/lib/utils";
-import { toast } from "sonner";
-import type { OmoGlobalConfig } from "@/types/omo";
-import {
-  OMO_DISABLEABLE_AGENTS,
-  OMO_DISABLEABLE_MCPS,
-  OMO_DISABLEABLE_HOOKS,
-  OMO_DISABLEABLE_SKILLS,
-  OMO_DEFAULT_SCHEMA_URL,
-  OMO_SISYPHUS_AGENT_PLACEHOLDER,
-  OMO_LSP_PLACEHOLDER,
-  OMO_EXPERIMENTAL_PLACEHOLDER,
-  OMO_BACKGROUND_TASK_PLACEHOLDER,
-  OMO_BROWSER_AUTOMATION_PLACEHOLDER,
-  OMO_CLAUDE_CODE_PLACEHOLDER,
-} from "@/types/omo";
-import {
-  useOmoGlobalConfig,
-  useSaveOmoGlobalConfig,
-  useReadOmoLocalFile,
-} from "@/lib/query/omo";
-
-interface PresetOption {
-  readonly value: string;
-  readonly label: string;
-}
-
-export interface OmoGlobalConfigFieldsRef {
-  buildCurrentConfig: () => OmoGlobalConfig;
-  buildCurrentConfigStrict: () => OmoGlobalConfig;
-  importFromLocal: () => Promise<void>;
-}
-
-interface OmoGlobalConfigFieldsProps {
-  onStateChange?: (config: OmoGlobalConfig) => void;
-  hideSaveButtons?: boolean;
-}
-
-type OmoAdvancedFieldKey =
-  | "lspStr"
-  | "experimentalStr"
-  | "backgroundTaskStr"
-  | "browserStr"
-  | "claudeCodeStr";
-
-const OMO_ADVANCED_JSON_FIELDS: ReadonlyArray<{
-  key: OmoAdvancedFieldKey;
-  labelKey: string;
-  defaultLabel: string;
-  placeholder: string;
-  minHeight: string;
-}> = [
-  {
-    key: "lspStr",
-    labelKey: "omo.advancedLsp",
-    defaultLabel: "LSP Config",
-    placeholder: OMO_LSP_PLACEHOLDER,
-    minHeight: "200px",
-  },
-  {
-    key: "experimentalStr",
-    labelKey: "omo.advancedExperimental",
-    defaultLabel: "Experimental Features",
-    placeholder: OMO_EXPERIMENTAL_PLACEHOLDER,
-    minHeight: "120px",
-  },
-  {
-    key: "backgroundTaskStr",
-    labelKey: "omo.advancedBackgroundTask",
-    defaultLabel: "Background Tasks",
-    placeholder: OMO_BACKGROUND_TASK_PLACEHOLDER,
-    minHeight: "250px",
-  },
-  {
-    key: "browserStr",
-    labelKey: "omo.advancedBrowserAutomation",
-    defaultLabel: "Browser Automation",
-    placeholder: OMO_BROWSER_AUTOMATION_PLACEHOLDER,
-    minHeight: "80px",
-  },
-  {
-    key: "claudeCodeStr",
-    labelKey: "omo.advancedClaudeCode",
-    defaultLabel: "Claude Code",
-    placeholder: OMO_CLAUDE_CODE_PLACEHOLDER,
-    minHeight: "180px",
-  },
-];
-
-function TagListEditor({
-  label,
-  values,
-  onChange,
-  placeholder,
-  presets,
-}: {
-  label: string;
-  values: string[];
-  onChange: (values: string[]) => void;
-  placeholder?: string;
-  presets?: readonly PresetOption[];
-}) {
-  const { t } = useTranslation();
-  const [open, setOpen] = useState(false);
-  const [search, setSearch] = useState("");
-
-  const toggleValue = (v: string) => {
-    if (values.includes(v)) {
-      onChange(values.filter((x) => x !== v));
-    } else {
-      onChange([...values, v]);
-    }
-  };
-  const customValue = search.trim();
-  const canAddCustom = customValue.length > 0 && !values.includes(customValue);
-  const triggerText =
-    values.length === 0
-      ? placeholder || t("omo.selectPlaceholder", { defaultValue: "Select..." })
-      : values.length === 1
-        ? values[0]
-        : `${values[0]} +${values.length - 1}`;
-
-  const availablePresets = presets?.filter(
-    (p) =>
-      !search.trim() ||
-      p.label.toLowerCase().includes(search.toLowerCase()) ||
-      p.value.toLowerCase().includes(search.toLowerCase()),
-  );
-
-  return (
-    <div className="space-y-1.5">
-      <div className="flex items-center justify-between">
-        <Label className="text-sm">{label}</Label>
-        {values.length > 0 && (
-          <Button
-            type="button"
-            variant="ghost"
-            size="sm"
-            className="h-6 px-1.5 text-xs text-muted-foreground"
-            onClick={() => onChange([])}
-          >
-            {t("omo.clear", { defaultValue: "Clear" })}
-          </Button>
-        )}
-      </div>
-      {values.length > 0 && (
-        <div className="flex flex-wrap gap-1">
-          {values.map((v, i) => (
-            <Badge
-              key={`${v}-${i}`}
-              variant="secondary"
-              className="text-xs gap-1"
-            >
-              {v}
-              <button
-                type="button"
-                onClick={() => onChange(values.filter((_, idx) => idx !== i))}
-                className="hover:text-destructive"
-              >
-                <X className="h-3 w-3" />
-              </button>
-            </Badge>
-          ))}
-        </div>
-      )}
-      <DropdownMenu open={open} onOpenChange={setOpen} modal={false}>
-        <DropdownMenuTrigger asChild>
-          <button
-            type="button"
-            className={cn(
-              "flex items-center justify-between w-full h-8 px-3 rounded-md border border-input bg-background text-sm",
-              "hover:bg-accent hover:text-accent-foreground transition-colors",
-              open && "ring-2 ring-ring",
-            )}
-            aria-expanded={open}
-          >
-            <span
-              className={cn(
-                "truncate",
-                values.length > 0 ? "text-foreground" : "text-muted-foreground",
-              )}
-            >
-              {triggerText}
-            </span>
-            <ChevronsUpDown className="h-4 w-4 shrink-0 text-muted-foreground" />
-          </button>
-        </DropdownMenuTrigger>
-        <DropdownMenuContent
-          align="start"
-          sideOffset={6}
-          className="w-[var(--radix-dropdown-menu-trigger-width)] p-0 z-[120]"
-        >
-          <div className="p-1.5 border-b border-border/30">
-            <Input
-              value={search}
-              onChange={(e) => setSearch(e.target.value)}
-              onKeyDown={(e) => {
-                e.stopPropagation();
-                if (e.key === "Enter" && canAddCustom) {
-                  e.preventDefault();
-                  onChange([...values, customValue]);
-                  setSearch("");
-                }
-              }}
-              placeholder={
-                placeholder ||
-                t("omo.searchOrType", {
-                  defaultValue: "Search or type custom value...",
-                })
-              }
-              className="h-7 text-sm"
-              autoFocus
-            />
-          </div>
-          {canAddCustom && (
-            <button
-              type="button"
-              className="w-full px-2.5 py-1.5 text-left text-sm border-b border-border/30 hover:bg-accent"
-              onMouseDown={(e) => e.preventDefault()}
-              onClick={() => {
-                onChange([...values, customValue]);
-                setSearch("");
-              }}
-            >
-              + {customValue}
-            </button>
-          )}
-          <div className="max-h-48 overflow-auto py-1">
-            {availablePresets && availablePresets.length > 0 ? (
-              availablePresets.map((p) => {
-                const checked = values.includes(p.value);
-                return (
-                  <DropdownMenuCheckboxItem
-                    key={p.value}
-                    checked={checked}
-                    onSelect={(e) => e.preventDefault()}
-                    onCheckedChange={() => toggleValue(p.value)}
-                    className="text-sm"
-                  >
-                    {p.label}
-                  </DropdownMenuCheckboxItem>
-                );
-              })
-            ) : (
-              <div className="px-2.5 py-2 text-sm text-muted-foreground">
-                {t("omo.noMatches", { defaultValue: "No matches" })}
-              </div>
-            )}
-          </div>
-        </DropdownMenuContent>
-      </DropdownMenu>
-    </div>
-  );
-}
-
-function JsonTextareaField({
-  label,
-  value,
-  onChange,
-  placeholder,
-  minHeight,
-}: {
-  label: string;
-  value: string;
-  onChange: (value: string) => void;
-  placeholder?: string;
-  minHeight?: string;
-}) {
-  return (
-    <div className="space-y-1.5">
-      <Label className="text-sm">{label}</Label>
-      <Textarea
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-        placeholder={placeholder || "{}"}
-        className="font-mono text-sm"
-        style={{ minHeight: minHeight || "100px" }}
-      />
-    </div>
-  );
-}
-
-export const OmoGlobalConfigFields = forwardRef<
-  OmoGlobalConfigFieldsRef,
-  OmoGlobalConfigFieldsProps
->(function OmoGlobalConfigFields({ onStateChange, hideSaveButtons }, ref) {
-  const { t } = useTranslation();
-  const { data: config } = useOmoGlobalConfig();
-  const saveMutation = useSaveOmoGlobalConfig();
-
-  const [schemaUrl, setSchemaUrl] = useState(OMO_DEFAULT_SCHEMA_URL);
-  const [sisyphusAgentStr, setSisyphusAgentStr] = useState("");
-  const [disabledAgents, setDisabledAgents] = useState<string[]>([]);
-  const [disabledMcps, setDisabledMcps] = useState<string[]>([]);
-  const [disabledHooks, setDisabledHooks] = useState<string[]>([]);
-  const [disabledSkills, setDisabledSkills] = useState<string[]>([]);
-  const [lspStr, setLspStr] = useState("");
-  const [experimentalStr, setExperimentalStr] = useState("");
-  const [backgroundTaskStr, setBackgroundTaskStr] = useState("");
-  const [browserStr, setBrowserStr] = useState("");
-  const [claudeCodeStr, setClaudeCodeStr] = useState("");
-  const [otherFieldsStr, setOtherFieldsStr] = useState("");
-  const [loaded, setLoaded] = useState(false);
-
-  const applyGlobalState = useCallback((global: OmoGlobalConfig) => {
-    setSchemaUrl(global.schemaUrl || OMO_DEFAULT_SCHEMA_URL);
-    setSisyphusAgentStr(
-      global.sisyphusAgent ? JSON.stringify(global.sisyphusAgent, null, 2) : "",
-    );
-    setDisabledAgents(global.disabledAgents || []);
-    setDisabledMcps(global.disabledMcps || []);
-    setDisabledHooks(global.disabledHooks || []);
-    setDisabledSkills(global.disabledSkills || []);
-    setLspStr(global.lsp ? JSON.stringify(global.lsp, null, 2) : "");
-    setExperimentalStr(
-      global.experimental ? JSON.stringify(global.experimental, null, 2) : "",
-    );
-    setBackgroundTaskStr(
-      global.backgroundTask
-        ? JSON.stringify(global.backgroundTask, null, 2)
-        : "",
-    );
-    setBrowserStr(
-      global.browserAutomationEngine
-        ? JSON.stringify(global.browserAutomationEngine, null, 2)
-        : "",
-    );
-    setClaudeCodeStr(
-      global.claudeCode ? JSON.stringify(global.claudeCode, null, 2) : "",
-    );
-    setOtherFieldsStr(
-      global.otherFields ? JSON.stringify(global.otherFields, null, 2) : "",
-    );
-  }, []);
-
-  useEffect(() => {
-    if (config && !loaded) {
-      applyGlobalState(config);
-      setLoaded(true);
-    }
-  }, [config, loaded, applyGlobalState]);
-
-  const parseJsonField = useCallback(
-    (
-      fieldName: string,
-      raw: string,
-      strict: boolean,
-    ): Record<string, unknown> | undefined => {
-      if (!raw.trim()) return undefined;
-      try {
-        const parsed: unknown = JSON.parse(raw);
-        if (
-          typeof parsed !== "object" ||
-          parsed === null ||
-          Array.isArray(parsed)
-        ) {
-          if (strict) {
-            throw new Error(
-              t("omo.jsonMustBeObject", {
-                field: fieldName,
-                defaultValue: "{{field}} must be a JSON object",
-              }),
-            );
-          }
-          return undefined;
-        }
-        return parsed as Record<string, unknown>;
-      } catch (error) {
-        if (strict) {
-          if (error instanceof Error) {
-            throw error;
-          }
-          throw new Error(
-            t("omo.jsonInvalid", {
-              field: fieldName,
-              defaultValue: "{{field}} contains invalid JSON",
-            }),
-          );
-        }
-        return undefined;
-      }
-    },
-    [t],
-  );
-
-  const buildCurrentConfigInternal = useCallback(
-    (strict: boolean): OmoGlobalConfig => {
-      return {
-        id: "global",
-        schemaUrl: schemaUrl || undefined,
-        sisyphusAgent: parseJsonField(
-          t("omo.sisyphusAgentConfig", {
-            defaultValue: "Sisyphus Agent",
-          }),
-          sisyphusAgentStr,
-          strict,
-        ),
-        disabledAgents,
-        disabledMcps,
-        disabledHooks,
-        disabledSkills,
-        lsp: parseJsonField(
-          t("omo.advancedLsp", { defaultValue: "LSP" }),
-          lspStr,
-          strict,
-        ),
-        experimental: parseJsonField(
-          t("omo.advancedExperimental", { defaultValue: "Experimental" }),
-          experimentalStr,
-          strict,
-        ),
-        backgroundTask: parseJsonField(
-          t("omo.advancedBackgroundTask", {
-            defaultValue: "Background Task",
-          }),
-          backgroundTaskStr,
-          strict,
-        ),
-        browserAutomationEngine: parseJsonField(
-          t("omo.advancedBrowserAutomation", {
-            defaultValue: "Browser Automation",
-          }),
-          browserStr,
-          strict,
-        ),
-        claudeCode: parseJsonField(
-          t("omo.advancedClaudeCode", { defaultValue: "Claude Code" }),
-          claudeCodeStr,
-          strict,
-        ),
-        otherFields: parseJsonField(
-          t("omo.otherFields", {
-            defaultValue: "Other Config",
-          }),
-          otherFieldsStr,
-          strict,
-        ),
-        updatedAt: new Date().toISOString(),
-      };
-    },
-    [
-      schemaUrl,
-      sisyphusAgentStr,
-      disabledAgents,
-      disabledMcps,
-      disabledHooks,
-      disabledSkills,
-      lspStr,
-      experimentalStr,
-      backgroundTaskStr,
-      browserStr,
-      claudeCodeStr,
-      otherFieldsStr,
-      parseJsonField,
-    ],
-  );
-
-  const buildCurrentConfig = useCallback(
-    () => buildCurrentConfigInternal(false),
-    [buildCurrentConfigInternal],
-  );
-
-  const buildCurrentConfigStrict = useCallback(
-    () => buildCurrentConfigInternal(true),
-    [buildCurrentConfigInternal],
-  );
-
-  useEffect(() => {
-    if (loaded && onStateChange) {
-      onStateChange(buildCurrentConfig());
-    }
-  }, [loaded, onStateChange, buildCurrentConfig]);
-
-  const handleSaveGlobal = useCallback(async () => {
-    try {
-      const result = buildCurrentConfigStrict();
-      await saveMutation.mutateAsync(result);
-      toast.success(
-        t("omo.globalConfigSaved", {
-          defaultValue: "Global config saved",
-        }),
-      );
-    } catch (err) {
-      toast.error(String(err));
-    }
-  }, [buildCurrentConfigStrict, saveMutation, t]);
-
-  const disabledCount =
-    disabledAgents.length +
-    disabledMcps.length +
-    disabledHooks.length +
-    disabledSkills.length;
-  const advancedFieldValues: Record<OmoAdvancedFieldKey, string> = {
-    lspStr,
-    experimentalStr,
-    backgroundTaskStr,
-    browserStr,
-    claudeCodeStr,
-  };
-
-  const advancedFieldSetters: Record<
-    OmoAdvancedFieldKey,
-    (value: string) => void
-  > = {
-    lspStr: setLspStr,
-    experimentalStr: setExperimentalStr,
-    backgroundTaskStr: setBackgroundTaskStr,
-    browserStr: setBrowserStr,
-    claudeCodeStr: setClaudeCodeStr,
-  };
-
-  const disabledEditorConfigs = [
-    {
-      key: "agents",
-      label: t("omo.disabledAgents", { defaultValue: "Agents" }),
-      values: disabledAgents,
-      onChange: setDisabledAgents,
-      placeholder: t("omo.disabledAgentsPlaceholder", {
-        defaultValue: "Disabled Agents",
-      }),
-      presets: OMO_DISABLEABLE_AGENTS,
-    },
-    {
-      key: "mcps",
-      label: t("omo.disabledMcps", { defaultValue: "MCPs" }),
-      values: disabledMcps,
-      onChange: setDisabledMcps,
-      placeholder: t("omo.disabledMcpsPlaceholder", {
-        defaultValue: "Disabled MCPs",
-      }),
-      presets: OMO_DISABLEABLE_MCPS,
-    },
-    {
-      key: "hooks",
-      label: t("omo.disabledHooks", { defaultValue: "Hooks" }),
-      values: disabledHooks,
-      onChange: setDisabledHooks,
-      placeholder: t("omo.disabledHooksPlaceholder", {
-        defaultValue: "Disabled Hooks",
-      }),
-      presets: OMO_DISABLEABLE_HOOKS,
-    },
-    {
-      key: "skills",
-      label: t("omo.disabledSkills", { defaultValue: "Skills" }),
-      values: disabledSkills,
-      onChange: setDisabledSkills,
-      placeholder: t("omo.disabledSkillsPlaceholder", {
-        defaultValue: "Disabled Skills",
-      }),
-      presets: OMO_DISABLEABLE_SKILLS,
-    },
-  ] as const;
-
-  const readLocalFile = useReadOmoLocalFile();
-
-  const handleImportGlobalFromLocal = useCallback(async () => {
-    try {
-      const data = await readLocalFile.mutateAsync();
-      applyGlobalState(data.global);
-      toast.success(
-        t("omo.importGlobalSuccess", {
-          defaultValue: "Imported global config from local file (unsaved)",
-        }),
-      );
-    } catch (err) {
-      toast.error(
-        t("omo.importGlobalFailed", {
-          error: String(err),
-          defaultValue: "Failed to read local file: {{error}}",
-        }),
-      );
-    }
-  }, [readLocalFile, applyGlobalState, t]);
-
-  useImperativeHandle(
-    ref,
-    () => ({
-      buildCurrentConfig,
-      buildCurrentConfigStrict,
-      importFromLocal: handleImportGlobalFromLocal,
-    }),
-    [buildCurrentConfig, buildCurrentConfigStrict, handleImportGlobalFromLocal],
-  );
-
-  return (
-    <div className="space-y-4">
-      {!hideSaveButtons && (
-        <div className="flex items-center justify-end gap-1.5">
-          <Button
-            type="button"
-            variant="ghost"
-            size="sm"
-            className="h-7 text-xs"
-            disabled={readLocalFile.isPending}
-            onClick={handleImportGlobalFromLocal}
-          >
-            {readLocalFile.isPending ? (
-              <Loader2 className="h-3.5 w-3.5 mr-1 animate-spin" />
-            ) : (
-              <FolderInput className="h-3.5 w-3.5 mr-1" />
-            )}
-            {t("omo.importLocal", { defaultValue: "Import Local" })}
-          </Button>
-          <Button
-            type="button"
-            variant="outline"
-            size="sm"
-            className="h-7 text-xs"
-            disabled={saveMutation.isPending}
-            onClick={handleSaveGlobal}
-          >
-            {saveMutation.isPending ? (
-              <Loader2 className="h-3.5 w-3.5 mr-1 animate-spin" />
-            ) : (
-              <Save className="h-3.5 w-3.5 mr-1" />
-            )}
-            {t("omo.saveGlobalConfig", { defaultValue: "Save Global Config" })}
-          </Button>
-        </div>
-      )}
-
-      <div className="space-y-1.5">
-        <div className="flex items-center justify-between">
-          <Label className="text-sm">
-            {t("omo.schemaUrl", { defaultValue: "$schema" })}
-          </Label>
-          {schemaUrl !== OMO_DEFAULT_SCHEMA_URL && (
-            <Button
-              type="button"
-              variant="ghost"
-              size="sm"
-              className="h-6 text-xs px-1.5"
-              onClick={() => setSchemaUrl(OMO_DEFAULT_SCHEMA_URL)}
-            >
-              <RotateCcw className="h-3 w-3 mr-0.5" />
-              {t("omo.resetDefault", { defaultValue: "Reset" })}
-            </Button>
-          )}
-        </div>
-        <Input
-          value={schemaUrl}
-          onChange={(e) => setSchemaUrl(e.target.value)}
-          placeholder={OMO_DEFAULT_SCHEMA_URL}
-          className="text-sm h-8"
-        />
-      </div>
-
-      <div className="rounded-md border border-border/40 bg-muted/10 p-2 space-y-2">
-        <Label className="text-sm font-semibold">
-          {t("omo.sisyphusAgentConfig", {
-            defaultValue: "Sisyphus Agent",
-          })}
-        </Label>
-        <Textarea
-          value={sisyphusAgentStr}
-          onChange={(e) => setSisyphusAgentStr(e.target.value)}
-          placeholder={OMO_SISYPHUS_AGENT_PLACEHOLDER}
-          className="font-mono text-sm"
-          style={{ minHeight: "140px" }}
-        />
-      </div>
-
-      <div className="rounded-md border border-border/40 bg-muted/10 p-2 space-y-3">
-        <div className="flex items-center gap-2">
-          <Label className="text-sm font-semibold">
-            {t("omo.disabledItems", { defaultValue: "Disabled Items" })}
-          </Label>
-          {disabledCount > 0 && (
-            <Badge variant="secondary" className="text-xs h-5">
-              {disabledCount}
-            </Badge>
-          )}
-        </div>
-        {disabledEditorConfigs.map((editor) => (
-          <TagListEditor
-            key={editor.key}
-            label={editor.label}
-            values={editor.values}
-            onChange={editor.onChange}
-            placeholder={editor.placeholder}
-            presets={editor.presets}
-          />
-        ))}
-      </div>
-
-      <div className="rounded-md border border-border/40 bg-muted/10 p-2 space-y-2">
-        <Label className="text-sm font-semibold">
-          {t("omo.advanced", { defaultValue: "Advanced Settings" })}
-        </Label>
-        {OMO_ADVANCED_JSON_FIELDS.map((field) => (
-          <JsonTextareaField
-            key={field.key}
-            label={t(field.labelKey, { defaultValue: field.defaultLabel })}
-            value={advancedFieldValues[field.key]}
-            onChange={advancedFieldSetters[field.key]}
-            placeholder={field.placeholder}
-            minHeight={field.minHeight}
-          />
-        ))}
-
-        <JsonTextareaField
-          label={t("omo.otherFields", {
-            defaultValue: "Other Config",
-          })}
-          value={otherFieldsStr}
-          onChange={setOtherFieldsStr}
-        />
-      </div>
-    </div>
-  );
-});

src/components/providers/forms/OpenClawFormFields.tsx

@@ -0,0 +1,472 @@
+import { useTranslation } from "react-i18next";
+import { useState, useRef, useCallback } from "react";
+import { FormLabel } from "@/components/ui/form";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Plus, Trash2, ChevronDown, ChevronRight } from "lucide-react";
+import { ApiKeySection } from "./shared";
+import { openclawApiProtocols } from "@/config/openclawProviderPresets";
+import type { ProviderCategory, OpenClawModel } from "@/types";
+
+interface OpenClawFormFieldsProps {
+  // Base URL
+  baseUrl: string;
+  onBaseUrlChange: (value: string) => void;
+
+  // API Key
+  apiKey: string;
+  onApiKeyChange: (value: string) => void;
+  category?: ProviderCategory;
+  shouldShowApiKeyLink: boolean;
+  websiteUrl: string;
+  isPartner?: boolean;
+  partnerPromotionKey?: string;
+
+  // API Protocol
+  api: string;
+  onApiChange: (value: string) => void;
+
+  // Models
+  models: OpenClawModel[];
+  onModelsChange: (models: OpenClawModel[]) => void;
+}
+
+export function OpenClawFormFields({
+  baseUrl,
+  onBaseUrlChange,
+  apiKey,
+  onApiKeyChange,
+  category,
+  shouldShowApiKeyLink,
+  websiteUrl,
+  isPartner,
+  partnerPromotionKey,
+  api,
+  onApiChange,
+  models,
+  onModelsChange,
+}: OpenClawFormFieldsProps) {
+  const { t } = useTranslation();
+  const [expandedModels, setExpandedModels] = useState<Record<number, boolean>>(
+    {},
+  );
+
+  // Stable key tracking for models list
+  const modelKeysRef = useRef<string[]>([]);
+  const getModelKeys = useCallback(() => {
+    // Grow keys array if models were added externally
+    while (modelKeysRef.current.length < models.length) {
+      modelKeysRef.current.push(crypto.randomUUID());
+    }
+    // Shrink if models were removed externally
+    if (modelKeysRef.current.length > models.length) {
+      modelKeysRef.current.length = models.length;
+    }
+    return modelKeysRef.current;
+  }, [models.length]);
+  const modelKeys = getModelKeys();
+
+  // Toggle advanced section for a model
+  const toggleModelAdvanced = (index: number) => {
+    setExpandedModels((prev) => ({ ...prev, [index]: !prev[index] }));
+  };
+
+  // Add a new model entry
+  const handleAddModel = () => {
+    modelKeysRef.current.push(crypto.randomUUID());
+    onModelsChange([
+      ...models,
+      {
+        id: "",
+        name: "",
+        contextWindow: undefined,
+        maxTokens: undefined,
+        cost: undefined,
+      },
+    ]);
+  };
+
+  // Remove a model entry
+  const handleRemoveModel = (index: number) => {
+    modelKeysRef.current.splice(index, 1);
+    const newModels = [...models];
+    newModels.splice(index, 1);
+    onModelsChange(newModels);
+    // Clean up expanded state
+    setExpandedModels((prev) => {
+      const updated = { ...prev };
+      delete updated[index];
+      return updated;
+    });
+  };
+
+  // Update model field
+  const handleModelChange = (
+    index: number,
+    field: keyof OpenClawModel,
+    value: unknown,
+  ) => {
+    const newModels = [...models];
+    newModels[index] = { ...newModels[index], [field]: value };
+    onModelsChange(newModels);
+  };
+
+  // Update model cost
+  const handleCostChange = (
+    index: number,
+    costField: "input" | "output" | "cacheRead" | "cacheWrite",
+    value: string,
+  ) => {
+    const newModels = [...models];
+    const numValue = parseFloat(value);
+    const currentCost = newModels[index].cost || { input: 0, output: 0 };
+    newModels[index] = {
+      ...newModels[index],
+      cost: {
+        ...currentCost,
+        [costField]: isNaN(numValue) ? undefined : numValue,
+      },
+    };
+    onModelsChange(newModels);
+  };
+
+  return (
+    <>
+      {/* API Protocol Selector */}
+      <div className="space-y-2">
+        <FormLabel htmlFor="openclaw-api">
+          {t("openclaw.apiProtocol", {
+            defaultValue: "API 协议",
+          })}
+        </FormLabel>
+        <Select value={api} onValueChange={onApiChange}>
+          <SelectTrigger id="openclaw-api">
+            <SelectValue
+              placeholder={t("openclaw.selectProtocol", {
+                defaultValue: "选择 API 协议",
+              })}
+            />
+          </SelectTrigger>
+          <SelectContent>
+            {openclawApiProtocols.map((protocol) => (
+              <SelectItem key={protocol.value} value={protocol.value}>
+                {protocol.label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        <p className="text-xs text-muted-foreground">
+          {t("openclaw.apiProtocolHint", {
+            defaultValue:
+              "选择与供应商 API 兼容的协议类型。大多数供应商使用 OpenAI Completions 格式。",
+          })}
+        </p>
+      </div>
+
+      {/* Base URL */}
+      <div className="space-y-2">
+        <FormLabel htmlFor="openclaw-baseurl">
+          {t("openclaw.baseUrl", { defaultValue: "API 端点" })}
+        </FormLabel>
+        <Input
+          id="openclaw-baseurl"
+          value={baseUrl}
+          onChange={(e) => onBaseUrlChange(e.target.value)}
+          placeholder="https://api.example.com/v1"
+        />
+        <p className="text-xs text-muted-foreground">
+          {t("openclaw.baseUrlHint", {
+            defaultValue: "供应商的 API 端点地址。",
+          })}
+        </p>
+      </div>
+
+      {/* API Key */}
+      <ApiKeySection
+        value={apiKey}
+        onChange={onApiKeyChange}
+        category={category}
+        shouldShowLink={shouldShowApiKeyLink}
+        websiteUrl={websiteUrl}
+        isPartner={isPartner}
+        partnerPromotionKey={partnerPromotionKey}
+      />
+
+      {/* Models Editor */}
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <FormLabel>
+            {t("openclaw.models", { defaultValue: "模型列表" })}
+          </FormLabel>
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            onClick={handleAddModel}
+            className="h-7 gap-1"
+          >
+            <Plus className="h-3.5 w-3.5" />
+            {t("openclaw.addModel", { defaultValue: "添加模型" })}
+          </Button>
+        </div>
+
+        {models.length === 0 ? (
+          <p className="text-sm text-muted-foreground py-2">
+            {t("openclaw.noModels", {
+              defaultValue: "暂无模型配置。点击添加模型来配置可用模型。",
+            })}
+          </p>
+        ) : (
+          <div className="space-y-4">
+            {models.map((model, index) => (
+              <div
+                key={modelKeys[index]}
+                className="p-3 border border-border/50 rounded-lg space-y-3"
+              >
+                {/* Model ID and Name row */}
+                <div className="flex items-center gap-2">
+                  <div className="flex-1 space-y-1">
+                    <label className="text-xs text-muted-foreground">
+                      {t("openclaw.modelId", { defaultValue: "模型 ID" })}
+                    </label>
+                    <Input
+                      value={model.id}
+                      onChange={(e) =>
+                        handleModelChange(index, "id", e.target.value)
+                      }
+                      placeholder={t("openclaw.modelIdPlaceholder", {
+                        defaultValue: "claude-3-sonnet",
+                      })}
+                    />
+                  </div>
+                  <div className="flex-1 space-y-1">
+                    <label className="text-xs text-muted-foreground">
+                      {t("openclaw.modelName", { defaultValue: "显示名称" })}
+                    </label>
+                    <Input
+                      value={model.name}
+                      onChange={(e) =>
+                        handleModelChange(index, "name", e.target.value)
+                      }
+                      placeholder={t("openclaw.modelNamePlaceholder", {
+                        defaultValue: "Claude 3 Sonnet",
+                      })}
+                    />
+                  </div>
+                  <Button
+                    type="button"
+                    variant="ghost"
+                    size="icon"
+                    onClick={() => handleRemoveModel(index)}
+                    className="h-9 w-9 mt-5 text-muted-foreground hover:text-destructive"
+                  >
+                    <Trash2 className="h-4 w-4" />
+                  </Button>
+                </div>
+
+                {/* Advanced Options (Collapsible) */}
+                <Collapsible
+                  open={expandedModels[index] ?? false}
+                  onOpenChange={() => toggleModelAdvanced(index)}
+                >
+                  <CollapsibleTrigger asChild>
+                    <Button
+                      type="button"
+                      variant="ghost"
+                      size="sm"
+                      className="h-7 gap-1 text-xs text-muted-foreground hover:text-foreground"
+                    >
+                      {expandedModels[index] ? (
+                        <ChevronDown className="h-3.5 w-3.5" />
+                      ) : (
+                        <ChevronRight className="h-3.5 w-3.5" />
+                      )}
+                      {t("openclaw.advancedOptions", {
+                        defaultValue: "高级选项",
+                      })}
+                    </Button>
+                  </CollapsibleTrigger>
+                  <CollapsibleContent className="space-y-3 pt-2">
+                    {/* Context Window, Max Tokens and Reasoning row */}
+                    <div className="flex items-center gap-2">
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.contextWindow", {
+                            defaultValue: "上下文窗口",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          value={model.contextWindow ?? ""}
+                          onChange={(e) =>
+                            handleModelChange(
+                              index,
+                              "contextWindow",
+                              e.target.value
+                                ? parseInt(e.target.value)
+                                : undefined,
+                            )
+                          }
+                          placeholder="200000"
+                        />
+                      </div>
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.maxTokens", {
+                            defaultValue: "最大输出 Tokens",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          value={model.maxTokens ?? ""}
+                          onChange={(e) =>
+                            handleModelChange(
+                              index,
+                              "maxTokens",
+                              e.target.value
+                                ? parseInt(e.target.value)
+                                : undefined,
+                            )
+                          }
+                          placeholder="32000"
+                        />
+                      </div>
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.reasoning", {
+                            defaultValue: "推理模式",
+                          })}
+                        </label>
+                        <div className="flex items-center h-9 gap-2">
+                          <Switch
+                            checked={model.reasoning ?? false}
+                            onCheckedChange={(checked) =>
+                              handleModelChange(index, "reasoning", checked)
+                            }
+                          />
+                          <span className="text-xs text-muted-foreground">
+                            {model.reasoning
+                              ? t("openclaw.reasoningOn", {
+                                  defaultValue: "启用",
+                                })
+                              : t("openclaw.reasoningOff", {
+                                  defaultValue: "关闭",
+                                })}
+                          </span>
+                        </div>
+                      </div>
+                    </div>
+
+                    {/* Cost row */}
+                    <div className="flex items-center gap-2">
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.inputCost", {
+                            defaultValue: "输入价格 ($/M tokens)",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          step="0.001"
+                          value={model.cost?.input ?? ""}
+                          onChange={(e) =>
+                            handleCostChange(index, "input", e.target.value)
+                          }
+                          placeholder="3"
+                        />
+                      </div>
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.outputCost", {
+                            defaultValue: "输出价格 ($/M tokens)",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          step="0.001"
+                          value={model.cost?.output ?? ""}
+                          onChange={(e) =>
+                            handleCostChange(index, "output", e.target.value)
+                          }
+                          placeholder="15"
+                        />
+                      </div>
+                      <div className="flex-1" />
+                    </div>
+
+                    {/* Cache Cost row */}
+                    <div className="flex items-center gap-2">
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.cacheReadCost", {
+                            defaultValue: "缓存读取价格 ($/M tokens)",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          step="0.001"
+                          value={model.cost?.cacheRead ?? ""}
+                          onChange={(e) =>
+                            handleCostChange(index, "cacheRead", e.target.value)
+                          }
+                          placeholder="0.3"
+                        />
+                      </div>
+                      <div className="flex-1 space-y-1">
+                        <label className="text-xs text-muted-foreground">
+                          {t("openclaw.cacheWriteCost", {
+                            defaultValue: "缓存写入价格 ($/M tokens)",
+                          })}
+                        </label>
+                        <Input
+                          type="number"
+                          step="0.001"
+                          value={model.cost?.cacheWrite ?? ""}
+                          onChange={(e) =>
+                            handleCostChange(
+                              index,
+                              "cacheWrite",
+                              e.target.value,
+                            )
+                          }
+                          placeholder="3.75"
+                        />
+                      </div>
+                      <div className="flex-1" />
+                    </div>
+                    <p className="text-xs text-muted-foreground">
+                      {t("openclaw.cacheCostHint", {
+                        defaultValue:
+                          "缓存价格用于计算 Prompt Caching 的成本。如不使用缓存可留空。",
+                      })}
+                    </p>
+                  </CollapsibleContent>
+                </Collapsible>
+              </div>
+            ))}
+          </div>
+        )}
+
+        <p className="text-xs text-muted-foreground">
+          {t("openclaw.modelsHint", {
+            defaultValue:
+              "配置该供应商支持的模型。模型 ID 用于 API 调用，显示名称用于界面展示。",
+          })}
+        </p>
+      </div>
+    </>
+  );
+}