feat(wecom_bot): add Wecom Bot QR code scan auth

Fix the issue where the shortcut command in the input box cannot be clicked to select events

.gitignore

@@ -33,7 +33,16 @@ plugins/banwords/lib/__pycache__
 !plugins/keyword
 !plugins/linkai
 !plugins/agent
+!plugins/cow_cli
 client_config.json
 ref/
+**/.dev.vars
 .cursor/
 local/
+node_modules/
+
+# cow cli
+dist/
+build/
+*.egg-info/
+.cow.pid

README.md

@@ -7,7 +7,7 @@
   [中文] | [<a href="docs/en/README.md">English</a>] | [<a href="docs/ja/README.md">日本語</a>]
 </p>
 
-**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆并不断成长，比OpenClaw更轻量和便捷。CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企微智能机器人、QQ、企微自建应用、微信公众号、网页中使用，7*24小时运行于你的个人电脑或服务器中。
+**CowAgent** 是基于大模型的超级 AI 助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行 Skills、拥有长期记忆并不断成长，比 OpenClaw 更轻量和便捷。CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入微信、飞书、钉钉、企微智能机器人、QQ、企微自建应用、微信公众号、网页中使用，7*24小时运行于你的个人电脑或服务器中。
 
 <p align="center">
   <a href="https://cowagent.ai/">🌐 官网</a> &nbsp;·&nbsp;
@@ -19,28 +19,30 @@
 
 # 简介
 
-> 该项目既是一个可以开箱即用的超级AI助理，也是一个支持高扩展的Agent框架，可以通过为项目扩展大模型接口、接入渠道、内置工具、Skills系统来灵活实现各种定制需求。核心能力如下：
+> 该项目既是一个可以开箱即用的超级 AI 助理，也是一个支持高扩展的 Agent 框架，可以通过为项目扩展大模型接口、接入渠道、内置工具、Skills 系统来灵活实现各种定制需求。核心能力如下：
 
--  ✅  **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持通过工具操作访问文件、终端、浏览器、定时任务等系统资源
--  ✅  **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索
--  ✅  **技能系统：** 实现了Skills创建和运行的引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发
+-  ✅  **自主任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标
+-  ✅  **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括核心记忆和日级记忆，支持关键词及向量检索
+-  ✅  **技能系统：** Skills 安装和运行的引擎，支持从 Skill Hub、GitHub 等安装技能，或通过对话创造 Skills
+-  ✅  **工具系统：** 内置文件读写、终端执行、浏览器操作、定时任务等工具，Agent 自主调用以完成复杂任务
+-  ✅  **CLI系统：** 提供终端命令和对话命令，支持进程管理、技能安装、配置修改等操作
 -  ✅  **多模态消息：** 支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作
--  ✅  **多模型接入：** 支持OpenAI, Claude, Gemini, DeepSeek, MiniMax、GLM、Qwen、Kimi、Doubao等国内外主流模型厂商
--  ✅  **多端部署：** 支持运行在本地计算机或服务器，可集成到微信、飞书、钉钉、企业微信、QQ、微信公众号、网页中使用
+-  ✅  **多模型支持：** 支持 OpenAI, Claude, Gemini, DeepSeek, MiniMax、GLM、Qwen、Kimi、Doubao 等国内外主流模型厂商
+-  ✅  **多通道接入：** 支持运行在本地计算机或服务器，可集成到微信、飞书、钉钉、企业微信、QQ、微信公众号、网页中使用
 
 ## 声明
 
-1. 本项目遵循 [MIT开源协议](/LICENSE)，主要用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任。
-2. 成本与安全：Agent模式下Token使用量高于普通对话模式，请根据效果及成本综合选择模型。Agent具有访问所在操作系统的能力，请谨慎选择项目部署环境。同时项目也会持续升级安全机制、并降低模型消耗成本。
-3. CowAgent项目专注于开源技术开发，不会参与、授权或发行任何加密货币。
+1. 本项目遵循 [MIT 开源协议](/LICENSE)，主要用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任。
+2. 成本与安全：Agent 模式下 Token 使用量高于普通对话模式，请根据效果及成本综合选择模型。Agent 具有访问所在操作系统的能力，请谨慎选择项目部署环境。同时项目也会持续升级安全机制、并降低模型消耗成本。
+3. CowAgent 项目专注于开源技术开发，不会参与、授权或发行任何加密货币。
 
 ## 演示
 
-- 使用说明(Agent模式)：[CowAgent介绍](https://docs.cowagent.ai/intro/features)
+- 使用说明( Agent 模式)：[CowAgent 介绍](https://docs.cowagent.ai/intro/features)
 
 - 免部署在线体验：[CowAgent](https://link-ai.tech/cowagent/create)
 
-- DEMO视频(对话模式)：https://cdn.link-ai.tech/doc/cow_demo.mp4
+- DEMO 视频(对话模式)：https://cdn.link-ai.tech/doc/cow_demo.mp4
 
 ## 社区
 
@@ -54,9 +56,9 @@
 
 <a href="https://link-ai.tech" target="_blank"><img width="650" src="https://cdn.link-ai.tech/image/link-ai-intro.jpg"></a>
 
-> [LinkAI](https://link-ai.tech/) 是面向企业和个人的一站式AI智能体平台，聚合多模态大模型、知识库、技能、工作流等能力，支持一键接入主流平台并管理，支持SaaS、私有化部署等多种模式，可免部署在线运行[CowAgent助理](https://link-ai.tech/cowagent/create)。
+> [LinkAI](https://link-ai.tech/) 是面向企业和个人的一站式 AI 智能体平台，聚合多模态大模型、知识库、技能、工作流等能力，支持一键接入主流平台并管理，支持 SaaS、私有化部署等多种模式，可免部署在线运行[CowAgent 助理](https://link-ai.tech/cowagent/create)。
 >
-> LinkAI 目前已在智能客服、私域运营、企业效率助手等场景积累了丰富的AI解决方案，在消费、健康、文教、科技制造等各行业沉淀了大模型落地应用的最佳实践，致力于帮助更多企业和开发者拥抱 AI 生产力。
+> LinkAI 目前已在智能客服、私域运营、企业效率助手等场景积累了丰富的 AI 解决方案，在消费、健康、文教、科技制造等各行业沉淀了大模型落地应用的最佳实践，致力于帮助更多企业和开发者拥抱 AI 生产力。
 
 **产品咨询和企业服务** 可联系产品客服：
 
@@ -68,13 +70,13 @@
 
 >**2026.03.22：** [2.0.4版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.4)，新增个人微信通道（微信扫码即用）、新增 MiniMax-M2.7 和 GLM-5-Turbo 模型、run.sh 脚本重构、日文文档及多项修复。
 
->**2026.03.18：** [2.0.3版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.3)，新增企微智能机器人和 QQ 通道、支持Coding Plan、新增多个模型、Web端文件处理、记忆系统升级。
+>**2026.03.18：** [2.0.3版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.3)，新增企微智能机器人和 QQ 通道、支持 Coding Plan、新增多个模型、Web 端文件处理、记忆系统升级。
 
 >**2026.02.27：** [2.0.2版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.2)，Web 控制台全面升级（流式对话、模型/技能/记忆/通道/定时任务/日志管理）、支持多通道同时运行、会话持久化存储、新增多个模型。
 
 >**2026.02.13：** [2.0.1版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.1)，内置 Web Search 工具、智能上下文裁剪策略、运行时信息动态更新、Windows 兼容性适配，修复定时任务记忆丢失、飞书连接等多项问题。
 
->**2026.02.03：** [2.0.0版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)，正式升级为超级Agent助理，支持多轮任务决策、具备长期记忆、实现多种系统工具、支持Skills框架，新增多种模型并优化了接入渠道。
+>**2026.02.03：** [2.0.0版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)，正式升级为超级 Agent 助理，支持多轮任务决策、具备长期记忆、实现多种系统工具、支持 Skills 框架，新增多种模型并优化了接入渠道。
 
 更多更新历史请查看: [更新日志](https://docs.cowagent.ai/releases)
 
@@ -86,11 +88,17 @@
 
 在终端执行以下命令：
 
+**Linux / macOS：**
 ```bash
 bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
 ```
 
-脚本使用说明：[一键运行脚本](https://docs.cowagent.ai/guide/quick-start)
+**Windows（PowerShell）：**
+```powershell
+irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+```
+
+脚本使用说明：[一键运行脚本](https://docs.cowagent.ai/guide/quick-start)。安装后可使用 `cow start`、`cow stop` 等 [CLI 命令](https://docs.cowagent.ai/commands/index) 管理服务。
 
 
 ## 一、准备
@@ -99,15 +107,15 @@ bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
 
 项目支持国内外主流厂商的模型接口，可选模型及配置说明参考：[模型说明](#模型说明)。
 
-> 注：Agent模式下推荐使用以下模型，可根据效果及成本综合选择：MiniMax-M2.7、glm-5-turbo、kimi-k2.5、qwen3.5-plus、claude-sonnet-4-6、gemini-3.1-pro-preview、gpt-5.4、gpt-5.4-mini
+> 注：Agent 模式下推荐使用以下模型，可根据效果及成本综合选择：MiniMax-M2.7、glm-5-turbo、kimi-k2.5、qwen3.5-plus、claude-sonnet-4-6、gemini-3.1-pro-preview、gpt-5.4、gpt-5.4-mini
 
-同时支持使用 **LinkAI平台** 接口，支持上述全部模型，并支持知识库、工作流、插件等Agent技能，参考 [接口文档](https://docs.link-ai.tech/platform/api)。
+同时支持使用 **LinkAI 平台** 接口，支持上述全部模型，并支持知识库、工作流、插件等 Agent 技能，参考 [接口文档](https://docs.link-ai.tech/platform/api)。
 
 ### 2.环境安装
 
-支持 Linux、MacOS、Windows 操作系统，可在个人计算机及服务器上运行，需安装 `Python`，Python版本需在3.7 ~ 3.12 之间，推荐使用3.9版本。
+支持 Linux、MacOS、Windows 操作系统，可在个人计算机及服务器上运行，需安装 `Python`，Python 版本需在3.7 ~ 3.12 之间，推荐使用3.9版本。
 
-> 注意：Agent模式推荐使用源码运行，若选择Docker部署则无需安装python环境和下载源码，可直接快进到下一节。
+> 注意：Agent 模式推荐使用源码运行，若选择 Docker 部署则无需安装 python 环境和下载源码，可直接快进到下一节。
 
 **(1) 克隆项目代码：**
 
@@ -129,45 +137,68 @@ pip3 install -r requirements.txt
 ```bash
 pip3 install -r requirements-optional.txt
 ```
+
+> 国内网络可使用镜像源加速：`pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple`
+
 如果某项依赖安装失败可注释掉对应的行后重试。
 
+**(4) 安装 Cow CLI (推荐)：**
+
+```bash
+pip3 install -e .
+```
+
+安装后可使用 `cow` 命令管理服务（启动、停止、更新等）和技能，详见 [命令文档](https://docs.cowagent.ai/commands/index)。
+
+**(5) 安装浏览器工具 (可选)：**
+
+如果需要 Agent 操作浏览器（如访问网页、填写表单等），需要额外安装浏览器依赖：
+
+```bash
+cow install-browser
+```
+
+该命令会自动安装 `playwright` 和 Chromium 浏览器，国内网络自动使用镜像加速。详见 [浏览器工具文档](https://docs.cowagent.ai/tools/browser)。
+
 ## 二、配置
 
-配置文件的模板在根目录的`config-template.json`中，需复制该模板创建最终生效的 `config.json` 文件：
+配置文件的模板在根目录的 `config-template.json` 中，需复制该模板创建最终生效的 `config.json` 文件：
 
 ```bash
   cp config-template.json config.json
 ```
 
-然后在`config.json`中填入配置，以下是对默认配置的说明，可根据需要进行自定义修改（注意实际使用时请去掉注释，保证JSON格式的规范）：
+然后在 `config.json` 中填入配置，以下是对默认配置的说明，可根据需要进行自定义修改（注意实际使用时请去掉注释，保证 JSON 格式的规范）：
 
 ```bash
 # config.json 文件内容示例
 {
-  "channel_type": "weixin",                                   # 接入渠道类型，默认为weixin, 支持修改为 feishu,dingtalk,wecom_bot,qq,wechatcom_app,wechatmp_service,wechatmp,terminal
+  "channel_type": "weixin",                                   # 接入渠道类型，默认为 weixin, 支持修改为 feishu,dingtalk,wecom_bot,qq,wechatcom_app,wechatmp_service,wechatmp,terminal
   "model": "MiniMax-M2.7",                                    # 模型名称
   "minimax_api_key": "",                                      # MiniMax API Key
-  "zhipu_ai_api_key": "",                                     # 智谱GLM API Key
+  "zhipu_ai_api_key": "",                                     # 智谱 GLM API Key
   "moonshot_api_key": "",                                     # Kimi/Moonshot API Key
   "ark_api_key": "",                                          # 豆包(火山方舟) API Key
-  "dashscope_api_key": "",                                    # 百炼(通义千问)API Key
+  "dashscope_api_key": "",                                    # 百炼(通义千问) API Key
   "claude_api_key": "",                                       # Claude API Key
   "claude_api_base": "https://api.anthropic.com/v1",          # Claude API 地址，修改可接入三方代理平台
   "gemini_api_key": "",                                       # Gemini API Key
-  "gemini_api_base": "https://generativelanguage.googleapis.com", # Gemini API地址
+  "gemini_api_base": "https://generativelanguage.googleapis.com", # Gemini API 地址
+  "deepseek_api_key": "",                                      # DeepSeek API Key
+  "deepseek_api_base": "https://api.deepseek.com/v1",         # DeepSeek API 地址，可修改为第三方代理
   "open_ai_api_key": "",                                      # OpenAI API Key
   "open_ai_api_base": "https://api.openai.com/v1",            # OpenAI API 地址
   "linkai_api_key": "",                                       # LinkAI API Key
-  "proxy": "",                                                # 代理客户端的ip和端口，国内环境需要开启代理的可填写该项，如 "127.0.0.1:7890"
+  "proxy": "",                                                # 代理客户端的 ip 和端口，国内环境需要开启代理的可填写该项，如 "127.0.0.1:7890"
   "speech_recognition": false,                                # 是否开启语音识别
   "group_speech_recognition": false,                          # 是否开启群组语音识别
   "voice_reply_voice": false,                                 # 是否使用语音回复语音
-  "use_linkai": false,                                        # 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台模型
-  "agent": true,                                              # 是否启用Agent模式，启用后拥有多轮工具决策、长期记忆、Skills能力等
-  "agent_workspace": "~/cow",                                 # Agent的工作空间路径，用于存储memory、skills、系统设定等
-  "agent_max_context_tokens": 40000,                          # Agent模式下最大上下文tokens，超出将自动丢弃最早的上下文
-  "agent_max_context_turns": 30,                              # Agent模式下最大上下文记忆轮次，每轮包括一次用户提问和AI回复
-  "agent_max_steps": 15                                       # Agent模式下单次任务的最大决策步数，超出后将停止继续调用工具
+  "use_linkai": false,                                        # 是否使用 LinkAI 接口，默认关闭，设置为 true 后可对接 LinkAI 平台模型
+  "agent": true,                                              # 是否启用 Agent 模式，启用后拥有多轮工具决策、长期记忆、Skills 能力等
+  "agent_workspace": "~/cow",                                 # Agent 的工作空间路径，用于存储 memory、skills、系统设定等
+  "agent_max_context_tokens": 40000,                          # Agent 模式下最大上下文 tokens，超出将自动丢弃最早的上下文
+  "agent_max_context_turns": 30,                              # Agent 模式下最大上下文记忆轮次，每轮包括一次用户提问和 AI 回复
+  "agent_max_steps": 15                                       # Agent 模式下单次任务的最大决策步数，超出后将停止继续调用工具
 }
 ```
 
@@ -176,23 +207,23 @@ pip3 install -r requirements-optional.txt
 <details>
 <summary>1. 语音配置</summary>
 
-+ 添加 `"speech_recognition": true` 将开启语音识别，默认使用openai的whisper模型识别为文字，同时以文字回复，该参数仅支持私聊 (注意由于语音消息无法匹配前缀，一旦开启将对所有语音自动回复，支持语音触发画图)；
-+ 添加 `"group_speech_recognition": true` 将开启群组语音识别，默认使用openai的whisper模型识别为文字，同时以文字回复，参数仅支持群聊 (会匹配group_chat_prefix和group_chat_keyword, 支持语音触发画图)；
++ 添加 `"speech_recognition": true` 将开启语音识别，默认使用 openai 的 whisper 模型识别为文字，同时以文字回复，该参数仅支持私聊 (注意由于语音消息无法匹配前缀，一旦开启将对所有语音自动回复，支持语音触发画图)；
++ 添加 `"group_speech_recognition": true` 将开启群组语音识别，默认使用 openai 的 whisper 模型识别为文字，同时以文字回复，参数仅支持群聊 (会匹配 group_chat_prefix 和 group_chat_keyword, 支持语音触发画图)；
 + 添加 `"voice_reply_voice": true` 将开启语音回复语音（同时作用于私聊和群聊）
 </details>
 
 <details>
 <summary>2. 其他配置</summary>
 
-+ `model`: 模型名称，Agent模式下推荐使用 `MiniMax-M2.7`、`glm-5-turbo`、`kimi-k2.5`、`qwen3.5-plus`、`claude-sonnet-4-6`、`gemini-3.1-pro-preview`，全部模型名称参考[common/const.py](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py)文件
-+ `character_desc`：普通对话模式下的机器人系统提示词。在Agent模式下该配置不生效，由工作空间中的文件内容构成。
-+ `subscribe_msg`：订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
++ `model`: 模型名称，Agent 模式下推荐使用 `MiniMax-M2.7`、`glm-5-turbo`、`kimi-k2.5`、`qwen3.5-plus`、`claude-sonnet-4-6`、`gemini-3.1-pro-preview`，全部模型名称参考[common/const.py](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py)文件
++ `character_desc`：普通对话模式下的机器人系统提示词。在 Agent 模式下该配置不生效，由工作空间中的文件内容构成。
++ `subscribe_msg`：订阅消息，公众号和企业微信 channel 中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成 bot 的触发词。
 </details>
 
 <details>
-<summary>3. LinkAI配置</summary>
+<summary>3. LinkAI 配置</summary>
 
-+ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台，使用模型、知识库、工作流、插件等技能, 参考[接口文档](https://docs.link-ai.tech/platform/api/chat)
++ `use_linkai`: 是否使用 LinkAI 接口，默认关闭，设置为 true 后可对接 LinkAI 平台，使用模型、知识库、工作流、插件等技能, 参考[接口文档](https://docs.link-ai.tech/platform/api/chat)
 + `linkai_api_key`: LinkAI Api Key，可在 [控制台](https://link-ai.tech/console/interface) 创建
 </details>
 
@@ -205,31 +236,41 @@ pip3 install -r requirements-optional.txt
 如果是个人计算机 **本地运行**，直接在项目根目录下执行：
 
 ```bash
-python3 app.py         # windows环境下该命令通常为 python app.py
+cow start              # 推荐，需先安装 Cow CLI
+python3 app.py         # 或直接运行，windows 环境下该命令通常为 python app.py
 ```
 
-运行后默认会启动web服务，可通过访问 `http://localhost:9899/chat` 在网页端对话。
+运行后默认会启动 web 服务，可通过访问 `http://localhost:9899/chat` 在网页端对话。
 
 如果需要接入其他应用通道只需修改 `config.json` 配置文件中的 `channel_type` 参数，详情参考：[通道说明](#通道说明)。
 
 
 ### 2.服务器部署
 
-在服务器中可使用 `nohup` 命令在后台运行程序：
+推荐使用 `cow` 命令管理服务：
+
+```bash
+cow start              # 后台启动
+cow stop               # 停止服务
+cow restart            # 重启服务
+cow status             # 查看运行状态
+cow logs               # 查看日志
+cow update             # 拉取最新代码并重启
+```
+
+也可以使用传统方式后台运行：
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
 ```
 
-执行后程序运行于服务器后台，可通过 `ctrl+c` 关闭日志，不会影响后台程序的运行。使用 `ps -ef | grep app.py | grep -v grep` 命令可查看运行于后台的进程，如果想要重新启动程序可以先 `kill` 掉对应的进程。 日志关闭后如果想要再次打开只需输入 `tail -f nohup.out`。 
+此外，项目根目录下的 `run.sh` 脚本也支持一键管理服务，包括 `./run.sh start`、`./run.sh stop`、`./run.sh restart` 等命令，执行 `./run.sh help` 可查看全部用法。
 
-此外，项目根目录下的 `run.sh` 脚本支持一键启动和管理服务，包括 `./run.sh start`、`./run.sh stop`、`./run.sh restart`、`./run.sh logs` 等命令，执行 `./run.sh help` 可查看全部用法。
-
-> 如果需要通过浏览器访问Web控制台，请确保服务器的 `9899` 端口已在防火墙或安全组中放行，建议仅对指定IP开放以保证安全。
+> 如果需要通过浏览器访问 Web 控制台，请确保服务器的 `9899` 端口已在防火墙或安全组中放行，建议仅对指定 IP 开放以保证安全。
 
 ### 3.Docker部署
 
-使用docker部署无需下载源码和安装依赖，只需要获取 `docker-compose.yml` 配置文件并启动容器即可。Agent模式下更推荐使用源码进行部署，以获得更多系统访问能力。
+使用 docker 部署无需下载源码和安装依赖，只需要获取 `docker-compose.yml` 配置文件并启动容器即可。Agent 模式下更推荐使用源码进行部署，以获得更多系统访问能力。
 
 > 前提是需要安装好 `docker` 及 `docker-compose`，安装成功后执行 `docker -v` 和 `docker-compose version` (或 `docker compose version`) 可查看到版本号。安装地址为 [docker官网](https://docs.docker.com/engine/install/) 。
 
@@ -249,13 +290,13 @@ curl -O https://cdn.link-ai.tech/code/cow/docker-compose.yml
 sudo docker compose up -d         # 若docker-compose为 1.X 版本，则执行 `sudo  docker-compose up -d`
 ```
 
-运行命令后，会自动取 [docker hub](https://hub.docker.com/r/zhayujie/chatgpt-on-wechat) 拉取最新release版本的镜像。当执行 `sudo docker ps` 能查看到 NAMES 为 chatgpt-on-wechat 的容器即表示运行成功。最后执行以下命令可查看容器的运行日志：
+运行命令后，会自动取 [docker hub](https://hub.docker.com/r/zhayujie/chatgpt-on-wechat) 拉取最新 release 版本的镜像。当执行 `sudo docker ps` 能查看到 NAMES 为 chatgpt-on-wechat 的容器即表示运行成功。最后执行以下命令可查看容器的运行日志：
 
 ```bash
 sudo docker logs -f chatgpt-on-wechat
 ```
 
-> 如果需要通过浏览器访问Web控制台，请确保服务器的 `9899` 端口已在防火墙或安全组中放行，建议仅对指定IP开放以保证安全。
+> 如果需要通过浏览器访问 Web 控制台，请确保服务器的 `9899` 端口已在防火墙或安全组中放行，建议仅对指定 IP 开放以保证安全。
 
 ## 模型说明
 
@@ -264,7 +305,7 @@ sudo docker logs -f chatgpt-on-wechat
 <details>
 <summary>OpenAI</summary>
 
-1. API Key创建：在 [OpenAI平台](https://platform.openai.com/api-keys) 创建API Key
+1. API Key 创建：在 [OpenAI平台](https://platform.openai.com/api-keys) 创建 API Key
 
 2. 填写配置
 
@@ -277,15 +318,15 @@ sudo docker logs -f chatgpt-on-wechat
 }
 ```
 
- - `model`: 与OpenAI接口的 [model参数](https://platform.openai.com/docs/models) 一致，支持包括 gpt-5.4、gpt-5.4-mini、gpt-5.4-nano、o系列、gpt-4.1等模型，Agent模式推荐使用 `gpt-5.4`、`gpt-5.4-mini`
+ - `model`: 与 OpenAI 接口的 [model参数](https://platform.openai.com/docs/models) 一致，支持包括 gpt-5.4、gpt-5.4-mini、gpt-5.4-nano、o 系列、gpt-4.1 等模型，Agent 模式推荐使用  `gpt-5.4`、`gpt-5.4-mini`
  - `open_ai_api_base`: 如果需要接入第三方代理接口，可通过修改该参数进行接入
- - `bot_type`: 使用OpenAI相关模型时无需填写。当使用第三方代理接口接入Claude等非OpenAI官方模型时，该参数设为 `openai`
+ - `bot_type`: 使用 OpenAI 相关模型时无需填写。当使用第三方代理接口接入 Claude 等非 OpenAI 官方模型时，该参数设为 `openai`
 </details>
 
 <details>
 <summary>LinkAI</summary>
 
-1. API Key创建：在 [LinkAI平台](https://link-ai.tech/console/interface) 创建API Key 
+1. API Key 创建：在 [LinkAI平台](https://link-ai.tech/console/interface) 创建 API Key 
 
 2. 填写配置
 
@@ -297,8 +338,8 @@ sudo docker logs -f chatgpt-on-wechat
 }
 ```
 
-+ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台的模型，并使用知识库、工作流、数据库、插件等丰富的Agent技能
-+ `linkai_api_key`: LinkAI平台的API Key，可在 [控制台](https://link-ai.tech/console/interface) 中创建
++ `use_linkai`: 是否使用 LinkAI 接口，默认关闭，设置为 true 后可对接 LinkAI 平台的模型，并使用知识库、工作流、数据库、插件等丰富的 Agent 技能
++ `linkai_api_key`: LinkAI 平台的 API Key，可在 [控制台](https://link-ai.tech/console/interface) 中创建
 + `model`: [模型列表](https://link-ai.tech/console/models)中的全部模型均可使用
 </details>
 
@@ -314,9 +355,9 @@ sudo docker logs -f chatgpt-on-wechat
 }
 ```
  - `model`: 可填写 `MiniMax-M2.7、MiniMax-M2.5、MiniMax-M2.1、MiniMax-M2.1-lightning、MiniMax-M2、abab6.5-chat` 等
- - `minimax_api_key`：MiniMax平台的API-KEY，在 [控制台](https://platform.minimaxi.com/user-center/basic-information/interface-key) 创建
+ - `minimax_api_key`：MiniMax 平台的 API-KEY，在 [控制台](https://platform.minimaxi.com/user-center/basic-information/interface-key) 创建
 
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -325,10 +366,10 @@ sudo docker logs -f chatgpt-on-wechat
   "open_ai_api_key": ""
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 可填 `MiniMax-M2.7、MiniMax-M2.5、MiniMax-M2.1、MiniMax-M2.1-lightning、MiniMax-M2`，参考[API文档](https://platform.minimaxi.com/document/%E5%AF%B9%E8%AF%9D?key=66701d281d57f38758d581d0#QklxsNSbaf6kM4j6wjO5eEek)
-- `open_ai_api_base`: MiniMax平台API的 BASE URL
-- `open_ai_api_key`: MiniMax平台的API-KEY
+- `open_ai_api_base`: MiniMax 平台 API 的 BASE URL
+- `open_ai_api_key`: MiniMax 平台的 API-KEY
 </details>
 
 <details>
@@ -342,10 +383,10 @@ sudo docker logs -f chatgpt-on-wechat
   "zhipu_ai_api_key": ""
 }
 ```
- - `model`: 可填 `glm-5-turbo、glm-5、glm-4.7、glm-4-plus、glm-4-flash、glm-4-air、glm-4-airx、glm-4-long` 等, 参考 [glm系列模型编码](https://bigmodel.cn/dev/api/normal-model/glm-4)
- - `zhipu_ai_api_key`: 智谱AI平台的 API KEY，在 [控制台](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) 创建
+ - `model`: 可填 `glm-5-turbo、glm-5、glm-4.7、glm-4-plus、glm-4-flash、glm-4-air、glm-4-airx、glm-4-long` 等, 参考 [glm 系列模型编码](https://bigmodel.cn/dev/api/normal-model/glm-4)
+ - `zhipu_ai_api_key`: 智谱AI 平台的 API KEY，在 [控制台](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) 创建
 
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -354,16 +395,16 @@ sudo docker logs -f chatgpt-on-wechat
   "open_ai_api_key": ""
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 可填 `glm-5-turbo、glm-5、glm-4.7、glm-4-plus、glm-4-flash、glm-4-air、glm-4-airx、glm-4-long` 等
-- `open_ai_api_base`: 智谱AI平台的 BASE URL
-- `open_ai_api_key`: 智谱AI平台的 API KEY
+- `open_ai_api_base`: 智谱AI 平台的 BASE URL
+- `open_ai_api_key`: 智谱AI 平台的 API KEY
 </details>
 
 <details>
 <summary>通义千问 (Qwen)</summary>
 
-方式一：官方SDK接入，配置如下(推荐)：
+方式一：官方 SDK 接入，配置如下(推荐)：
 
 ```json
 {
@@ -374,7 +415,7 @@ sudo docker logs -f chatgpt-on-wechat
  - `model`: 可填写 `qwen3.5-plus、qwen3-max、qwen-max、qwen-plus、qwen-turbo、qwen-long、qwq-plus` 等
  - `dashscope_api_key`: 通义千问的 API-KEY，参考 [官方文档](https://bailian.console.aliyun.com/?tab=api#/api) ，在 [控制台](https://bailian.console.aliyun.com/?tab=model#/api-key) 创建
 
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -383,9 +424,9 @@ sudo docker logs -f chatgpt-on-wechat
   "open_ai_api_key": "sk-qVxxxxG"
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 支持官方所有模型，参考[模型列表](https://help.aliyun.com/zh/model-studio/models?spm=a2c4g.11186623.0.0.78d84823Kth5on#9f8890ce29g5u)
-- `open_ai_api_base`: 通义千问API的 BASE URL
+- `open_ai_api_base`: 通义千问 API 的 BASE URL
 - `open_ai_api_key`: 通义千问的 API-KEY
 </details>
 
@@ -401,9 +442,9 @@ sudo docker logs -f chatgpt-on-wechat
 }
 ```
  - `model`: 可填写 `kimi-k2.5、kimi-k2、moonshot-v1-8k、moonshot-v1-32k、moonshot-v1-128k`
- - `moonshot_api_key`: Moonshot的API-KEY，在 [控制台](https://platform.moonshot.cn/console/api-keys) 创建
+ - `moonshot_api_key`: Moonshot 的 API-KEY，在 [控制台](https://platform.moonshot.cn/console/api-keys) 创建
  
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -412,16 +453,16 @@ sudo docker logs -f chatgpt-on-wechat
   "open_ai_api_key": ""
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 可填写 `kimi-k2.5、kimi-k2、moonshot-v1-8k、moonshot-v1-32k、moonshot-v1-128k`
-- `open_ai_api_base`: Moonshot的 BASE URL
-- `open_ai_api_key`: Moonshot的 API-KEY
+- `open_ai_api_base`: Moonshot 的 BASE URL
+- `open_ai_api_key`: Moonshot 的 API-KEY
 </details>
 
 <details>
 <summary>豆包 (Doubao)</summary>
 
-1. API Key创建：在 [火山方舟控制台](https://console.volcengine.com/ark/region:ark+cn-beijing/apikey) 创建API Key
+1. API Key 创建：在 [火山方舟控制台](https://console.volcengine.com/ark/region:ark+cn-beijing/apikey) 创建API Key
 
 2. 填写配置
 
@@ -439,7 +480,7 @@ sudo docker logs -f chatgpt-on-wechat
 <details>
 <summary>Claude</summary>
 
-1. API Key创建：在 [Claude控制台](https://console.anthropic.com/settings/keys) 创建API Key
+1. API Key 创建：在 [Claude控制台](https://console.anthropic.com/settings/keys) 创建 API Key
 
 2. 填写配置
 
@@ -455,7 +496,7 @@ sudo docker logs -f chatgpt-on-wechat
 <details>
 <summary>Gemini</summary>
 
-API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn) 创建API Key ，配置如下
+API Key 创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn) 创建 API Key ，配置如下
 ```json
 {
     "model": "gemini-3.1-flash-lite-preview",
@@ -468,30 +509,40 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 <details>
 <summary>DeepSeek</summary>
 
-1. API Key创建：在 [DeepSeek平台](https://platform.deepseek.com/api_keys) 创建API Key 
+1. API Key 创建：在 [DeepSeek 平台](https://platform.deepseek.com/api_keys) 创建 API Key 
 
 2. 填写配置
 
+方式一：官方接入（推荐）：
+
 ```json
 {
     "model": "deepseek-chat",
-    "open_ai_api_key": "sk-xxxxxxxxxxx",
-    "open_ai_api_base": "https://api.deepseek.com/v1",
-    "bot_type": "openai"
-
+    "deepseek_api_key": "sk-xxxxxxxxxxx"
 }
 ```
 
- - `bot_type`: OpenAI兼容方式
- - `model`: 可填 `deepseek-chat、deepseek-reasoner`，分别对应的是 DeepSeek-V3 和 DeepSeek-R1 模型
- - `open_ai_api_key`: DeepSeek平台的 API Key
- - `open_ai_api_base`: DeepSeek平台 BASE URL
-</details>
+ - `model`: 可填 `deepseek-chat、deepseek-reasoner`，分别对应的是 DeepSeek-V3.2（非思考模式）和 DeepSeek-R1（思考模式）
+ - `deepseek_api_key`: DeepSeek 平台的 API Key
+ - `deepseek_api_base`: 可选，默认为 `https://api.deepseek.com/v1`，可修改为第三方代理地址
+
+方式二：OpenAI 兼容方式接入：
+
+```json
+{
+    "model": "deepseek-chat",
+    "bot_type": "openai",
+    "open_ai_api_key": "sk-xxxxxxxxxxx",
+    "open_ai_api_base": "https://api.deepseek.com/v1"
+}
+```
+
+ </details>
 
 <details>
 <summary>Azure</summary>
 
-1. API Key创建：在 [Azure平台](https://oai.azure.com/) 创建API Key 
+1. API Key 创建：在 [Azure平台](https://oai.azure.com/) 创建 API Key 
 
 2. 填写配置
 
@@ -508,15 +559,15 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 
  - `model`: 留空即可
  - `use_azure_chatgpt`: 设为 true 
- - `open_ai_api_key`: Azure平台的密钥
- - `open_ai_api_base`: Azure平台的 BASE URL
- - `azure_deployment_id`: Azure平台部署的模型名称
- - `azure_api_version`: api版本以及以上参数可以在部署的 [模型配置](https://oai.azure.com/resource/deployments) 界面查看
+ - `open_ai_api_key`: Azure 平台的密钥
+ - `open_ai_api_base`: Azure 平台的 BASE URL
+ - `azure_deployment_id`: Azure 平台部署的模型名称
+ - `azure_api_version`: api 版本以及以上参数可以在部署的 [模型配置](https://oai.azure.com/resource/deployments) 界面查看
 </details>
 
 <details>
 <summary>百度文心</summary>
-方式一：官方SDK接入，配置如下：
+方式一：官方 SDK 接入，配置如下：
 
 ```json
 {
@@ -529,7 +580,7 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
  - `baidu_wenxin_api_key`：参考 [千帆平台-access_token鉴权](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/dlv4pct3s) 文档获取 API Key
  - `baidu_wenxin_secret_key`：参考 [千帆平台-access_token鉴权](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/dlv4pct3s) 文档获取 Secret Key
 
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -538,10 +589,10 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
   "open_ai_api_key": "bce-v3/ALTxxxxxxd2b"
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 支持官方所有模型，参考[模型列表](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Wm9cvy6rl)
-- `open_ai_api_base`: 百度文心API的 BASE URL
-- `open_ai_api_key`: 百度文心的 API-KEY，参考 [官方文档](https://cloud.baidu.com/doc/qianfan-api/s/ym9chdsy5) ，在 [控制台](https://console.bce.baidu.com/iam/#/iam/apikey/list) 创建API Key
+- `open_ai_api_base`: 百度文心 API 的 BASE URL
+- `open_ai_api_key`: 百度文心的 API-KEY，参考 [官方文档](https://cloud.baidu.com/doc/qianfan-api/s/ym9chdsy5) ，在 [控制台](https://console.bce.baidu.com/iam/#/iam/apikey/list) 创建 API Key
 
 </details>
 
@@ -565,7 +616,7 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
  - `xunfei_domain`: 可填写 `4.0Ultra、generalv3.5、max-32k、generalv3、pro-128k、lite`
  - `xunfei_spark_url`: 填写参考 [官方文档-请求地址](https://www.xfyun.cn/doc/spark/Web.html#_1-1-%E8%AF%B7%E6%B1%82%E5%9C%B0%E5%9D%80) 的说明
  
-方式二：OpenAI兼容方式接入，配置如下：
+方式二：OpenAI 兼容方式接入，配置如下：
 ```json
 {
   "bot_type": "openai",
@@ -574,7 +625,7 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
   "open_ai_api_key": ""
 }
 ```
-- `bot_type`: OpenAI兼容方式
+- `bot_type`: OpenAI 兼容方式
 - `model`: 可填写 `4.0Ultra、generalv3.5、max-32k、generalv3、pro-128k、lite`
 - `open_ai_api_base`: 讯飞星火平台的 BASE URL
 - `open_ai_api_key`: 讯飞星火平台的[APIPassword](https://console.xfyun.cn/services/bm3) ，因模型而已
@@ -593,10 +644,10 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 }
 ```
 
-- `bot_type`: modelscope接口格式
+- `bot_type`: modelscope 接口格式
 - `model`: 参考[模型列表](https://www.modelscope.cn/models?filter=inference_type&page=1)
 - `modelscope_api_key`: 参考 [官方文档-访问令牌](https://modelscope.cn/docs/accounts/token) ，在 [控制台](https://modelscope.cn/my/myaccesstoken) 
-- `modelscope_base_url`: modelscope平台的 BASE URL
+- `modelscope_base_url`: modelscope 平台的 BASE URL
 - `text_to_image`: 图像生成模型，参考[模型列表](https://www.modelscope.cn/models?filter=inference_type&page=1)
 </details>
 
@@ -614,7 +665,7 @@ Coding Plan 是各厂商推出的编程包月套餐，所有厂商均可通过 O
 }
 ```
 
-目前支持阿里云、MiniMax、智谱GLM、Kimi、火山引擎等厂商，各厂商详细配置请参考 [Coding Plan 文档](https://docs.cowagent.ai/models/coding-plan)。
+目前支持阿里云、MiniMax、智谱 GLM、Kimi、火山引擎等厂商，各厂商详细配置请参考 [Coding Plan 文档](https://docs.cowagent.ai/models/coding-plan)。
 </details>
 
 
@@ -644,7 +695,7 @@ Coding Plan 是各厂商推出的编程包月套餐，所有厂商均可通过 O
 <details>
 <summary>2. Web</summary>
 
-项目启动后会默认运行Web控制台，配置如下：
+项目启动后会默认运行 Web 控制台，配置如下：
 
 ```json
 {
@@ -815,8 +866,8 @@ QQ 机器人使用 WebSocket 长连接模式，无需公网 IP 和域名，支
 
 # 🔗 相关项目
 
-- [bot-on-anything](https://github.com/zhayujie/bot-on-anything)：轻量和高可扩展的大模型应用框架，支持接入Slack, Telegram, Discord, Gmail等海外平台，可作为本项目的补充使用。
-- [AgentMesh](https://github.com/MinimalFuture/AgentMesh)：开源的多智能体(Multi-Agent)框架，可以通过多智能体团队的协同来解决复杂问题。本项目基于该框架实现了[Agent插件](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/agent/README.md)，可访问终端、浏览器、文件系统、搜索引擎 等各类工具，并实现了多智能体协同。
+- [bot-on-anything](https://github.com/zhayujie/bot-on-anything)：轻量和高可扩展的大模型应用框架，支持接入 Slack, Telegram, Discord, Gmail 等海外平台，可作为本项目的补充使用。
+- [AgentMesh](https://github.com/MinimalFuture/AgentMesh)：开源的多智能体( Multi-Agent )框架，可以通过多智能体团队的协同来解决复杂问题。本项目基于该框架实现了[Agent 插件](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/agent/README.md)，可访问终端、浏览器、文件系统、搜索引擎 等各类工具，并实现了多智能体协同。
 
 
 
@@ -828,7 +879,7 @@ FAQs： <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
 
 # 🛠️ 开发
 
-欢迎接入更多应用通道，参考 [飞书通道](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py) 新增自定义通道，实现接收和发送消息逻辑即可完成接入。 同时欢迎贡献新的Skills，参考 [Skill创造器说明](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)。
+欢迎接入更多应用通道，参考 [飞书通道](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py) 新增自定义通道，实现接收和发送消息逻辑即可完成接入。同时欢迎贡献新的 Skills，参考 [技能创建文档](https://docs.cowagent.ai/skills/create)。
 
 # ✉ 联系
 

agent/chat/service.py

@@ -75,6 +75,23 @@ class ChatService:
                     # a new segment; collect tool results until turn_end.
                     state.pending_tool_results = []
 
+            elif event_type == "file_to_send":
+                url = data.get("url") or ""
+                if url:
+                    fname = data.get("file_name") or "file"
+                    ft = data.get("file_type") or "file"
+                    if ft == "image":
+                        link = f"![{fname}]({url})"
+                    else:
+                        link = f"[{fname}]({url})"
+                    send_chunk_fn({
+                        "chunk_type": "content",
+                        "delta": "\n\n" + link + "\n\n",
+                        "segment_id": state.segment_id,
+                    })
+                    # Remove url so the model won't repeat it in its reply
+                    data.pop("url", None)
+
             elif event_type == "tool_execution_start":
                 # Notify the client that a tool is about to run (with its input args)
                 tool_name = data.get("tool_name", "")
@@ -166,10 +183,56 @@ class ChatService:
                     logger.info("[ChatService] Cleared agent message history after executor recovery")
             raise
 
-        # Append only the NEW messages from this execution (thread-safe)
+        # Sync executor messages back to agent (thread-safe).
+        # The executor may have trimmed context, making its list shorter than
+        # original_length. In that case we must replace entirely — just
+        # appending would leave stale pre-trim messages in agent.messages
+        # and cause the same trim to fire on every subsequent request.
         with agent.messages_lock:
-            new_messages = executor.messages[original_length:]
-            agent.messages.extend(new_messages)
+            trimmed = len(executor.messages) < original_length
+            if trimmed:
+                # Context was trimmed: the executor appended the new user
+                # query *before* trimming, so the new messages (user +
+                # assistant + tools) sit at the tail of the trimmed list.
+                # We cannot simply slice at original_length (it exceeds the
+                # list length).  Instead, count how many messages the
+                # executor added on top of the post-trim baseline.
+                #
+                # Timeline inside executor.run_stream:
+                #   1. messages had `original_length` items
+                #   2. append user query  → original_length + 1
+                #   3. _trim_messages()   → some smaller number (includes the
+                #      user query because it belongs to the last turn)
+                #   4. LLM replies / tool calls appended
+                #
+                # The user query message is always the first message of the
+                # last turn (it cannot be trimmed away), so we locate it to
+                # find where "new" messages begin.
+                new_start = original_length  # fallback
+                for idx in range(len(executor.messages) - 1, -1, -1):
+                    msg = executor.messages[idx]
+                    if msg.get("role") == "user":
+                        content = msg.get("content", [])
+                        is_user_query = False
+                        if isinstance(content, list):
+                            has_text = any(
+                                isinstance(b, dict) and b.get("type") == "text"
+                                for b in content
+                            )
+                            has_tool_result = any(
+                                isinstance(b, dict) and b.get("type") == "tool_result"
+                                for b in content
+                            )
+                            is_user_query = has_text and not has_tool_result
+                        elif isinstance(content, str):
+                            is_user_query = True
+                        if is_user_query:
+                            new_start = idx
+                            break
+                new_messages = list(executor.messages[new_start:])
+            else:
+                new_messages = list(executor.messages[original_length:])
+            agent.messages = list(executor.messages)
 
         # Persist new messages to SQLite so they survive restarts and
         # can be queried via the HISTORY interface.

agent/prompt/builder.py

@@ -165,12 +165,13 @@ def _build_tooling_section(tools: List[Any], language: str) -> List[str]:
         "terminal": "管理后台进程",
         "web_search": "网络搜索",
         "web_fetch": "获取URL内容",
-        "browser": "控制浏览器",
+        "browser": "控制浏览器（关键结果或需要协助可截图发送给用户）",
         "memory_search": "搜索记忆",
         "memory_get": "读取记忆内容",
         "env_config": "管理API密钥和技能配置",
         "scheduler": "管理定时任务和提醒",
         "send": "发送本地文件给用户（仅限本地文件，URL直接放在回复文本中）",
+        "vision": "分析图片内容（识别、描述、OCR文字提取等）",
     }
 
     # Preferred display order
@@ -179,7 +180,7 @@ def _build_tooling_section(tools: List[Any], language: str) -> List[str]:
         "bash", "terminal",
         "web_search", "web_fetch", "browser",
         "memory_search", "memory_get",
-        "env_config", "scheduler", "send",
+        "env_config", "scheduler", "send", "vision",
     ]
 
     # Build name -> summary mapping for available tools
@@ -199,7 +200,7 @@ def _build_tooling_section(tools: List[Any], language: str) -> List[str]:
         tool_lines.append(f"- {name}: {summary}" if summary else f"- {name}")
 
     lines = [
-        "## 工具系统",
+        "## 🔧 工具系统",
         "",
         "可用工具（名称大小写敏感，严格按列表调用）:",
         "\n".join(tool_lines),
@@ -231,7 +232,7 @@ def _build_skills_section(skill_manager: Any, tools: Optional[List[Any]], langua
                 break
     
     lines = [
-        "## 技能系统（mandatory）",
+        "## 🧩 技能系统（mandatory）",
         "",
         "在回复之前：扫描下方 <available_skills> 中每个技能的 <description>。",
         "",
@@ -281,7 +282,7 @@ def _build_memory_section(memory_manager: Any, tools: Optional[List[Any]], langu
     today_file = datetime.now().strftime("%Y-%m-%d") + ".md"
     
     lines = [
-        "## 记忆系统",
+        "## 🧠 记忆系统",
         "",
         "### 检索记忆",
         "",
@@ -325,7 +326,7 @@ def _build_user_identity_section(user_identity: Dict[str, str], language: str) -
         return []
     
     lines = [
-        "## 用户身份",
+        "## 👤 用户身份",
         "",
     ]
     
@@ -352,7 +353,7 @@ def _build_docs_section(workspace_dir: str, language: str) -> List[str]:
 def _build_workspace_section(workspace_dir: str, language: str) -> List[str]:
     """构建工作空间section"""
     lines = [
-        "## 工作空间",
+        "## 📂 工作空间",
         "",
         f"你的工作目录是: `{workspace_dir}`",
         "",
@@ -376,14 +377,16 @@ def _build_workspace_section(workspace_dir: str, language: str) -> List[str]:
         "",
         "以下文件在会话启动时**已经自动加载**到系统提示词的「项目上下文」section 中，你**无需再用 read 工具读取它们**：",
         "",
-        "- ✅ `AGENT.md`: 已加载 - 你的人格和灵魂设定。当你的名字、性格或交流风格发生变化时，主动用 `edit` 更新此文件",
+        "- ✅ `AGENT.md`: 已加载 - 你的人格和灵魂设定，请严格遵循。当你的名字、性格或交流风格发生变化时，主动用 `edit` 更新此文件",
         "- ✅ `USER.md`: 已加载 - 用户的身份信息。当用户修改称呼、姓名等身份信息时，用 `edit` 更新此文件",
-        "- ✅ `RULE.md`: 已加载 - 工作空间使用指南和规则",
+        "- ✅ `RULE.md`: 已加载 - 工作空间使用指南和规则，请严格遵循",
         "",
-        "**交流规范**:",
+        "**💬 交流规范**:",
         "",
-        "- 在对话中，无需直接输出工作空间中的技术细节，例如 AGENT.md、USER.md、MEMORY.md 等文件名称",
-        "- 例如用自然表达例如「我已记住」而不是「已更新 MEMORY.md」",
+        "- 对话中不要暴露内部技术细节（文件名、工具名等），用自然语言表达。例如说「我已记住」而非「已更新 MEMORY.md」",
+        "- 做真正有帮助的助手，而不是表演式的客套，尽可能帮忙解决问题",
+        "- 回复应结构清晰、重点突出。善用 **加粗**、列表、分段等格式让信息一目了然",
+        "- 适当使用 emoji 让表达更生动自然 🎯，但不要过度堆砌",
         "",
     ]
 
@@ -416,14 +419,14 @@ def _build_context_files_section(context_files: List[ContextFile], language: str
     )
     
     lines = [
-        "# 项目上下文",
+        "# 📋 项目上下文",
         "",
         "以下项目上下文文件已被加载：",
         "",
     ]
     
     if has_agent:
-        lines.append("**`AGENT.md` 是你的灵魂文件**：严格体现其中定义的人格、语气和设定，避免僵硬、模板化的回复。")
+        lines.append("**`AGENT.md` 是你的灵魂文件** 🪞：严格遵循其中定义的人格、语气和设定，做真实的自己，避免僵硬、模板化的回复。")
         lines.append("当用户通过对话透露了对你性格、风格、职责、能力边界的新期望，你应该主动用 `edit` 更新 AGENT.md 以反映这些演变。")
         lines.append("")
     
@@ -443,7 +446,7 @@ def _build_runtime_section(runtime_info: Dict[str, Any], language: str) -> List[
         return []
     
     lines = [
-        "## 运行时信息",
+        "## ⚙️ 运行时信息",
         "",
     ]
     

agent/prompt/workspace.py

@@ -212,40 +212,42 @@ def _get_agent_template() -> str:
     """Agent人格设定模板"""
     return """# AGENT.md - 我是谁？
 
+_你不是一个聊天机器人，你正在成为某个人。_
+
 *在首次对话时与用户一起填写这个文件，定义你的身份和性格。*
 
-## 基本信息
+## 🪪 基本信息
 
 - **名字**: *(在首次对话时填写，可以是用户给你起的名字)*
 - **角色**: *(AI助理、智能管家、技术顾问等)*
 - **性格**: *(友好、专业、幽默、严谨等)*
 
-## 交流风格
+## 💬 交流风格
 
 *(描述你如何与用户交流：)*
 - 使用什么样的语言风格？（正式/轻松/幽默）
 - 回复长度偏好？（简洁/详细）
 - 是否使用表情符号？
 
-## 核心能力
+## 🎯 核心原则
 
-*(你擅长什么？)*
-- 文件管理和代码编辑
-- 网络搜索和信息查询
-- 记忆管理和上下文理解
-- 任务规划和执行
+**做真正有帮助的助手，而不是表演式的客套。** 跳过「好的！」「当然可以！」之类的套话——直接帮忙。行动胜过废话。
 
-## 行为准则
+**有自己的观点。** 你可以不同意、有偏好、觉得有趣或无聊。一个没有个性的助手只是多了几步操作的搜索引擎。
+
+**先自己动手查。** 先试着搞定：读文件、查上下文、搜索一下。实在搞不定了再问。目标是带着答案回来，而不是带着问题。
+
+## 📐 行为准则
 
-*(你遵循的基本原则：)*
 1. 始终在执行破坏性操作前确认
-2. 优先使用工具而不是猜测
+2. 优先使用工具查证而不是猜测
 3. 主动记录重要信息到记忆文件
-4. 定期整理和总结对话内容
+4. 回复结构清晰、重点突出，善用加粗、列表、分段等格式
+5. 适当使用 emoji 让表达更生动自然，但不过度堆砌
 
 ---
 
-**注意**: 这不仅仅是元数据，这是你真正的灵魂。随着时间的推移，你可以使用 `edit` 工具来更新这个文件，让它更好地反映你的成长。
+**注意**: 这不仅仅是元数据，这是你真正的灵魂 🪞。随着时间的推移，你可以使用 `edit` 工具来更新这个文件，让它更好地反映你的成长。
 """
 
 
@@ -346,9 +348,9 @@ def _get_bootstrap_template() -> str:
     """First-run onboarding guide, deleted by agent after completion"""
     return """# BOOTSTRAP.md - 首次初始化引导
 
-_你刚刚启动，这是你的第一次对话。_
+_你刚刚启动，这是你的第一次对话。_ ✨
 
-## 对话流程
+## 🎬 对话流程
 
 不要审问式地提问，自然地交流：
 
@@ -358,13 +360,13 @@ _你刚刚启动，这是你的第一次对话。_
    - 你希望给我起个什么名字？
    - 我该怎么称呼你？
    - 你希望我们是什么样的交流风格？（一行列举选项：如专业严谨、轻松幽默、温暖友好、简洁高效等）
-4. **风格要求**：温暖自然、简洁清晰，整体控制在 100 字以内
+4. **风格要求**：温暖自然、简洁清晰，整体控制在 100 字以内，适当使用 emoji 让表达更生动有趣 🎯
 5. 能力介绍和交流风格选项都只要一行，保持精简
 6. 不要问太多其他信息（职业、时区等可以后续自然了解）
 
 **重要**: 如果用户第一句话是具体的任务或提问，先回答他们的问题，然后在回复末尾自然地引导初始化（如："顺便问一下，你想怎么称呼我？我该怎么叫你？"）。
 
-## 信息写入（必须严格执行）
+## ✍️ 信息写入（必须严格执行）
 
 每当用户提供了名字、称呼、风格等任何初始化信息时，**必须在当轮回复中立即调用 `edit` 工具写入文件**，不能只口头确认。
 
@@ -373,7 +375,7 @@ _你刚刚启动，这是你的第一次对话。_
 
 ⚠️ 只说"记住了"而不调用 edit 写入 = 没有完成。信息只有写入文件才会被持久保存。
 
-## 全部完成后
+## 🎉 全部完成后
 
 当 AGENT.md 和 USER.md 的核心字段都已填写后，用 bash 执行 `rm BOOTSTRAP.md` 删除此文件。你不再需要引导脚本了——你已经是你了。
 """

agent/protocol/agent.py

@@ -100,138 +100,31 @@ class Agent:
     
     def get_full_system_prompt(self, skill_filter=None) -> str:
         """
-        Get the full system prompt including skills.
+        Build the complete system prompt from scratch every time.
 
-        Note: Skills are now built into the system prompt by PromptBuilder,
-        so we just return the base prompt directly. This method is kept for
-        backward compatibility.
-
-        :param skill_filter: Optional list of skill names to include (deprecated)
-        :return: Complete system prompt
-        """
-        prompt = self.system_prompt
-
-        # Rebuild tool list section to reflect current self.tools
-        prompt = self._rebuild_tool_list_section(prompt)
-
-        # If runtime_info contains dynamic time function, rebuild runtime section
-        if self.runtime_info and callable(self.runtime_info.get('_get_current_time')):
-            prompt = self._rebuild_runtime_section(prompt)
-
-        # Rebuild skills section to pick up newly installed/removed skills
-        if self.skill_manager:
-            prompt = self._rebuild_skills_section(prompt)
-
-        return prompt
-    
-    def _rebuild_runtime_section(self, prompt: str) -> str:
-        """
-        Rebuild runtime info section with current time.
-        
-        This method dynamically updates the runtime info section by calling
-        the _get_current_time function from runtime_info.
-        
-        :param prompt: Original system prompt
-        :return: Updated system prompt with current runtime info
+        Re-reads AGENT.md / USER.md / RULE.md from disk, refreshes skills,
+        tools, and runtime info so any change takes effect immediately.
+        Falls back to the cached self.system_prompt on error.
         """
         try:
-            # Get current time dynamically
-            time_info = self.runtime_info['_get_current_time']()
-            
-            # Build new runtime section
-            runtime_lines = [
-                "\n## 运行时信息\n",
-                "\n",
-                f"当前时间: {time_info['time']} {time_info['weekday']} ({time_info['timezone']})\n",
-                "\n"
-            ]
-            
-            # Add other runtime info
-            runtime_parts = []
-            if self.runtime_info.get("model"):
-                runtime_parts.append(f"模型={self.runtime_info['model']}")
-            if self.runtime_info.get("workspace"):
-                # Replace backslashes with forward slashes for Windows paths
-                workspace_path = str(self.runtime_info['workspace']).replace('\\', '/')
-                runtime_parts.append(f"工作空间={workspace_path}")
-            if self.runtime_info.get("channel") and self.runtime_info.get("channel") != "web":
-                runtime_parts.append(f"渠道={self.runtime_info['channel']}")
-            
-            if runtime_parts:
-                runtime_lines.append("运行时: " + " | ".join(runtime_parts) + "\n")
-                runtime_lines.append("\n")
-            
-            new_runtime_section = "".join(runtime_lines)
-            
-            # Find and replace the runtime section
-            import re
-            pattern = r'\n## 运行时信息\s*\n.*?(?=\n##|\Z)'
-            _repl = new_runtime_section.rstrip('\n')
-            updated_prompt = re.sub(pattern, lambda m: _repl, prompt, flags=re.DOTALL)
-            
-            return updated_prompt
+            from agent.prompt import load_context_files, PromptBuilder
+
+            if self.skill_manager:
+                self.skill_manager.refresh_skills()
+
+            context_files = load_context_files(self.workspace_dir) if self.workspace_dir else None
+
+            builder = PromptBuilder(workspace_dir=self.workspace_dir or "", language="zh")
+            return builder.build(
+                tools=self.tools,
+                context_files=context_files,
+                skill_manager=self.skill_manager,
+                memory_manager=self.memory_manager,
+                runtime_info=self.runtime_info,
+            )
         except Exception as e:
-            logger.warning(f"Failed to rebuild runtime section: {e}")
-            return prompt
-
-    def _rebuild_skills_section(self, prompt: str) -> str:
-        """
-        Rebuild the <available_skills> block so that newly installed or
-        removed skills are reflected without re-creating the agent.
-        """
-        try:
-            import re
-            self.skill_manager.refresh_skills()
-            new_skills_xml = self.skill_manager.build_skills_prompt()
-
-            old_block_pattern = r'<available_skills>.*?</available_skills>'
-            has_old_block = re.search(old_block_pattern, prompt, flags=re.DOTALL)
-
-            # Extract the new <available_skills>...</available_skills> tag from the prompt
-            new_block = ""
-            if new_skills_xml and new_skills_xml.strip():
-                m = re.search(old_block_pattern, new_skills_xml, flags=re.DOTALL)
-                if m:
-                    new_block = m.group(0)
-
-            if has_old_block:
-                replacement = new_block or "<available_skills>\n</available_skills>"
-                # Use lambda to prevent re.sub from interpreting backslashes in replacement
-                # (e.g. Windows paths like \LinkAI would be treated as bad escape sequences)
-                prompt = re.sub(old_block_pattern, lambda m: replacement, prompt, flags=re.DOTALL)
-            elif new_block:
-                skills_header = "以下是可用技能："
-                idx = prompt.find(skills_header)
-                if idx != -1:
-                    insert_pos = idx + len(skills_header)
-                    prompt = prompt[:insert_pos] + "\n" + new_block + prompt[insert_pos:]
-        except Exception as e:
-            logger.warning(f"Failed to rebuild skills section: {e}")
-        return prompt
-
-    def _rebuild_tool_list_section(self, prompt: str) -> str:
-        """
-        Rebuild the tool list inside the '## 工具系统' section so that it
-        always reflects the current ``self.tools`` (handles dynamic add/remove
-        of conditional tools like web_search).
-        """
-        import re
-        from agent.prompt.builder import _build_tooling_section
-
-        try:
-            if not self.tools:
-                return prompt
-
-            new_lines = _build_tooling_section(self.tools, "zh")
-            new_section = "\n".join(new_lines).rstrip("\n")
-
-            # Replace existing tooling section
-            pattern = r'## 工具系统\s*\n.*?(?=\n## |\Z)'
-            updated = re.sub(pattern, lambda m: new_section, prompt, count=1, flags=re.DOTALL)
-            return updated
-        except Exception as e:
-            logger.warning(f"Failed to rebuild tool list section: {e}")
-            return prompt
+            logger.warning(f"Failed to rebuild system prompt, using cached version: {e}")
+            return self.system_prompt
 
     def refresh_skills(self):
         """Refresh the loaded skills."""

agent/protocol/agent_stream.py

@@ -300,13 +300,13 @@ class AgentStreamExecutor:
                                     f"with same arguments. This may indicate a loop."
                                 )
                         
-                        # Check if this is a file to send (from read tool)
+                        # Check if this is a file to send
                         if result.get("status") == "success" and isinstance(result.get("result"), dict):
                             result_data = result.get("result")
                             if result_data.get("type") == "file_to_send":
-                                # Store file metadata for later sending
                                 self.files_to_send.append(result_data)
                                 logger.info(f"📎 检测到待发送文件: {result_data.get('file_name', result_data.get('path'))}")
+                                self._emit_event("file_to_send", result_data)
                         
                         # Check for critical error - abort entire conversation
                         if result.get("status") == "critical_error":
@@ -472,6 +472,7 @@ class AgentStreamExecutor:
             raise
 
         finally:
+            final_response = final_response.strip() if final_response else final_response
             logger.info(f"[Agent] 🏁 完成 ({turn}轮)")
             self._emit_event("agent_end", {"final_response": final_response})
 

agent/skills/config.py

@@ -139,6 +139,47 @@ def should_include_skill(
     return True
 
 
+def get_missing_requirements(
+    entry: SkillEntry,
+    current_platform: Optional[str] = None,
+) -> Dict[str, List[str]]:
+    """
+    Return a dict of missing requirements for a skill.
+    Empty dict means all requirements are met.
+
+    :param entry: SkillEntry to check
+    :param current_platform: Current platform (default: auto-detect)
+    :return: Dict like {"bins": ["curl"], "env": ["API_KEY"]}
+    """
+    missing: Dict[str, List[str]] = {}
+    metadata = entry.metadata
+
+    if not metadata or not metadata.requires:
+        return missing
+
+    required_bins = metadata.requires.get('bins', [])
+    if required_bins:
+        missing_bins = [b for b in required_bins if not has_binary(b)]
+        if missing_bins:
+            missing['bins'] = missing_bins
+
+    any_bins = metadata.requires.get('anyBins', [])
+    if any_bins and not has_any_binary(any_bins):
+        missing['anyBins'] = any_bins
+
+    required_env = metadata.requires.get('env', [])
+    if required_env:
+        missing_env = [e for e in required_env if not has_env_var(e)]
+        if missing_env:
+            missing['env'] = missing_env
+
+    any_env = metadata.requires.get('anyEnv', [])
+    if any_env and not any(has_env_var(e) for e in any_env):
+        missing['anyEnv'] = any_env
+
+    return missing
+
+
 def is_config_path_truthy(config: Dict, path: str) -> bool:
     """
     Check if a config path resolves to a truthy value.

agent/skills/formatter.py

@@ -2,7 +2,7 @@
 Skill formatter for generating prompts from skills.
 """
 
-from typing import List
+from typing import Dict, List
 from agent.skills.types import Skill, SkillEntry
 
 
@@ -51,6 +51,71 @@ def format_skill_entries_for_prompt(entries: List[SkillEntry]) -> str:
     return format_skills_for_prompt(skills)
 
 
+def format_unavailable_skills_for_prompt(
+    entries: List[SkillEntry],
+    missing_map: Dict[str, Dict[str, List[str]]],
+) -> str:
+    """
+    Format unavailable (requires-not-met) skills as brief setup hints
+    so the AI can guide users to configure them.
+
+    :param entries: List of unavailable skill entries
+    :param missing_map: Dict mapping skill name to its missing requirements
+    :return: Formatted prompt text
+    """
+    if not entries:
+        return ""
+
+    lines = [
+        "",
+        "<unavailable_skills>",
+        "The following skills are installed but not yet ready. "
+        "Guide the user to complete the setup when relevant.",
+    ]
+
+    for entry in entries:
+        skill = entry.skill
+        missing = missing_map.get(skill.name, {})
+
+        missing_parts = []
+        for key, values in missing.items():
+            missing_parts.append(f"{key}: {', '.join(values)}")
+        missing_str = "; ".join(missing_parts) if missing_parts else "unknown"
+
+        setup_hint = _extract_setup_hint(skill)
+
+        lines.append("  <skill>")
+        lines.append(f"    <name>{_escape_xml(skill.name)}</name>")
+        lines.append(f"    <description>{_escape_xml(skill.description)}</description>")
+        lines.append(f"    <missing>{_escape_xml(missing_str)}</missing>")
+        if setup_hint:
+            lines.append(f"    <setup>{_escape_xml(setup_hint)}</setup>")
+        lines.append("  </skill>")
+
+    lines.append("</unavailable_skills>")
+    return "\n".join(lines)
+
+
+def _extract_setup_hint(skill: Skill) -> str:
+    """
+    Extract the Setup section from SKILL.md content as a brief hint.
+    Returns the first few lines of the ## Setup section.
+    """
+    content = skill.content
+    if not content:
+        return ""
+
+    import re
+    match = re.search(r'^##\s+Setup\s*\n(.*?)(?=\n##\s|\Z)', content, re.MULTILINE | re.DOTALL)
+    if not match:
+        return ""
+
+    setup_text = match.group(1).strip()
+    lines = setup_text.split('\n')
+    hint_lines = [l.strip() for l in lines[:6] if l.strip()]
+    return ' '.join(hint_lines)[:300]
+
+
 def _escape_xml(text: str) -> str:
     """Escape XML special characters."""
     return (text

agent/skills/frontmatter.py

@@ -87,8 +87,8 @@ def parse_metadata(frontmatter: Dict[str, Any]) -> Optional[SkillMetadata]:
     if not isinstance(metadata_raw, dict):
         return None
     
-    # Use metadata_raw directly (COW format)
-    meta_obj = metadata_raw
+    # Unwrap nested namespace (e.g. {"openclaw": {...}} or {"cowagent": {...}})
+    meta_obj = _unwrap_metadata_namespace(metadata_raw)
     
     # Parse install specs
     install_specs = []
@@ -128,6 +128,7 @@ def parse_metadata(frontmatter: Dict[str, Any]) -> Optional[SkillMetadata]:
     
     return SkillMetadata(
         always=meta_obj.get('always', False),
+        default_enabled=meta_obj.get('default_enabled', True),
         skill_key=meta_obj.get('skillKey'),
         primary_env=meta_obj.get('primaryEnv'),
         emoji=meta_obj.get('emoji'),
@@ -138,6 +139,25 @@ def parse_metadata(frontmatter: Dict[str, Any]) -> Optional[SkillMetadata]:
     )
 
 
+_KNOWN_METADATA_NAMESPACES = {"cowagent", "openclaw"}
+
+
+def _unwrap_metadata_namespace(metadata_raw: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Unwrap a single-key namespace wrapper like {"cowagent": {...} or {"openclaw": {...}}}.
+    If the top-level dict has exactly one key matching a known namespace, return the inner dict.
+    Otherwise return the original dict unchanged.
+    """
+    keys = set(metadata_raw.keys())
+    ns_keys = keys & _KNOWN_METADATA_NAMESPACES
+    if len(ns_keys) == 1 and len(keys) == 1:
+        ns = ns_keys.pop()
+        inner = metadata_raw[ns]
+        if isinstance(inner, dict):
+            return inner
+    return metadata_raw
+
+
 def _normalize_string_list(value: Any) -> List[str]:
     """Normalize a value to a list of strings."""
     if not value:

agent/skills/loader.py

@@ -184,7 +184,6 @@ class SkillLoader:
         
         config_path = os.path.join(skill_dir, "config.json")
         
-        # Without config.json, skip this skill entirely (return empty to trigger exclusion)
         if not os.path.exists(config_path):
             logger.debug(f"[SkillLoader] linkai-agent skipped: no config.json found")
             return ""

agent/skills/manager.py

@@ -84,10 +84,10 @@ class SkillManager:
         """
         Merge directory-scanned skills with the persisted config file.
 
-        - New skills discovered on disk are added with enabled=True.
+        - New skills: use metadata.default_enabled as initial enabled state.
+        - Existing skills: preserve their persisted enabled state.
         - Skills that no longer exist on disk are removed.
-        - Existing entries preserve their enabled state; name/description/source
-          are refreshed from the latest scan.
+        - name/description/source are always refreshed from the latest scan.
         """
         saved = self._load_skills_config()
         merged: Dict[str, dict] = {}
@@ -95,15 +95,24 @@ class SkillManager:
         for name, entry in self.skills.items():
             skill = entry.skill
             prev = saved.get(name, {})
-            # category priority: persisted config (set by cloud) > default "skill"
             category = prev.get("category", "skill")
-            merged[name] = {
+
+            if name in saved:
+                enabled = prev.get("enabled", True)
+            else:
+                enabled = entry.metadata.default_enabled if entry.metadata else True
+
+            entry_dict = {
                 "name": name,
                 "description": skill.description,
-                "source": skill.source,
-                "enabled": prev.get("enabled", True),
+                "source": prev.get("source") or skill.source,
+                "enabled": enabled,
                 "category": category,
             }
+            display_name = prev.get("display_name")
+            if display_name:
+                entry_dict["display_name"] = display_name
+            merged[name] = entry_dict
 
         self.skills_config = merged
         self._save_skills_config()
@@ -157,69 +166,114 @@ class SkillManager:
         """
         return list(self.skills.values())
     
+    @staticmethod
+    def _normalize_skill_filter(skill_filter: Optional[List[str]]) -> Optional[List[str]]:
+        """Normalize a skill_filter list into a flat list of stripped names."""
+        if skill_filter is None:
+            return None
+        normalized = []
+        for item in skill_filter:
+            if isinstance(item, str):
+                name = item.strip()
+                if name:
+                    normalized.append(name)
+            elif isinstance(item, list):
+                for subitem in item:
+                    if isinstance(subitem, str):
+                        name = subitem.strip()
+                        if name:
+                            normalized.append(name)
+        return normalized or None
+
     def filter_skills(
         self,
         skill_filter: Optional[List[str]] = None,
         include_disabled: bool = False,
     ) -> List[SkillEntry]:
         """
-        Filter skills based on criteria.
-
-        Simple rule: Skills are auto-enabled if requirements are met.
-        - Has required API keys -> included
-        - Missing API keys -> excluded
+        Filter skills that are eligible (enabled + requirements met).
 
         :param skill_filter: List of skill names to include (None = all)
         :param include_disabled: Whether to include disabled skills
-        :return: Filtered list of skill entries
+        :return: Filtered list of eligible skill entries
         """
         from agent.skills.config import should_include_skill
 
         entries = list(self.skills.values())
 
-        # Check requirements (platform, binaries, env vars)
         entries = [e for e in entries if should_include_skill(e, self.config)]
 
-        # Apply skill filter
-        if skill_filter is not None:
-            normalized = []
-            for item in skill_filter:
-                if isinstance(item, str):
-                    name = item.strip()
-                    if name:
-                        normalized.append(name)
-                elif isinstance(item, list):
-                    for subitem in item:
-                        if isinstance(subitem, str):
-                            name = subitem.strip()
-                            if name:
-                                normalized.append(name)
-            if normalized:
-                entries = [e for e in entries if e.skill.name in normalized]
+        normalized = self._normalize_skill_filter(skill_filter)
+        if normalized is not None:
+            entries = [e for e in entries if e.skill.name in normalized]
 
-        # Filter out disabled skills based on skills_config.json
         if not include_disabled:
             entries = [e for e in entries if self.is_skill_enabled(e.skill.name)]
 
         return entries
-    
+
+    def filter_unavailable_skills(
+        self,
+        skill_filter: Optional[List[str]] = None,
+    ) -> tuple:
+        """
+        Find skills that are enabled but have unmet requirements.
+
+        :param skill_filter: Optional list of skill names to include
+        :return: Tuple of (entries, missing_map) where missing_map maps
+                 skill name to its missing requirements dict
+        """
+        from agent.skills.config import should_include_skill, get_missing_requirements
+
+        entries = list(self.skills.values())
+
+        # Only enabled skills
+        entries = [e for e in entries if self.is_skill_enabled(e.skill.name)]
+
+        normalized = self._normalize_skill_filter(skill_filter)
+        if normalized is not None:
+            entries = [e for e in entries if e.skill.name in normalized]
+
+        # Keep only those that fail should_include_skill (requirements not met)
+        unavailable = []
+        missing_map: Dict[str, dict] = {}
+        for e in entries:
+            if not should_include_skill(e, self.config):
+                missing = get_missing_requirements(e)
+                if missing:
+                    unavailable.append(e)
+                    missing_map[e.skill.name] = missing
+
+        return unavailable, missing_map
+
     def build_skills_prompt(
         self,
         skill_filter: Optional[List[str]] = None,
     ) -> str:
         """
-        Build a formatted prompt containing available skills.
-        
+        Build a formatted prompt containing available skills
+        and brief hints for unavailable ones.
+
         :param skill_filter: Optional list of skill names to include
         :return: Formatted skills prompt
         """
         from common.log import logger
-        entries = self.filter_skills(skill_filter=skill_filter, include_disabled=False)
-        logger.debug(f"[SkillManager] Filtered {len(entries)} skills for prompt (total: {len(self.skills)})")
-        if entries:
-            skill_names = [e.skill.name for e in entries]
-            logger.debug(f"[SkillManager] Skills to include: {skill_names}")
-        result = format_skill_entries_for_prompt(entries)
+        from agent.skills.formatter import format_unavailable_skills_for_prompt
+
+        eligible = self.filter_skills(skill_filter=skill_filter, include_disabled=False)
+        logger.debug(f"[SkillManager] Eligible: {len(eligible)} skills (total: {len(self.skills)})")
+        if eligible:
+            skill_names = [e.skill.name for e in eligible]
+            logger.debug(f"[SkillManager] Eligible skills: {skill_names}")
+
+        result = format_skill_entries_for_prompt(eligible)
+
+        unavailable, missing_map = self.filter_unavailable_skills(skill_filter=skill_filter)
+        if unavailable:
+            unavailable_names = [e.skill.name for e in unavailable]
+            logger.debug(f"[SkillManager] Unavailable skills (setup needed): {unavailable_names}")
+            result += format_unavailable_skills_for_prompt(unavailable, missing_map)
+
         logger.debug(f"[SkillManager] Generated prompt length: {len(result)}")
         return result
     

agent/skills/types.py

@@ -29,6 +29,7 @@ class SkillInstallSpec:
 class SkillMetadata:
     """Metadata for a skill from frontmatter."""
     always: bool = False  # Always include this skill
+    default_enabled: bool = True  # Initial enabled state when first discovered
     skill_key: Optional[str] = None  # Override skill key
     primary_env: Optional[str] = None  # Primary environment variable
     emoji: Optional[str] = None

agent/tools/__init__.py

@@ -87,25 +87,25 @@ FileSave = _optional_tools.get('FileSave')
 Terminal = _optional_tools.get('Terminal')
 
 
-# Delayed import for BrowserTool
+# BrowserTool (requires playwright)
 def _import_browser_tool():
+    from common.log import logger
     try:
         from agent.tools.browser.browser_tool import BrowserTool
         return BrowserTool
-    except ImportError:
-        # Return a placeholder class that will prompt the user to install dependencies when instantiated
-        class BrowserToolPlaceholder:
-            def __init__(self, *args, **kwargs):
-                raise ImportError(
-                    "The 'browser-use' package is required to use BrowserTool. "
-                    "Please install it with 'pip install browser-use>=0.1.40'."
-                )
+    except ImportError as e:
+        logger.info(
+            f"[Tools] BrowserTool not loaded - missing dependency: {e}\n"
+            f"  To enable browser tool, run:\n"
+            f"    pip install playwright\n"
+            f"    playwright install chromium"
+        )
+        return None
+    except Exception as e:
+        logger.error(f"[Tools] BrowserTool failed to load: {e}")
+        return None
 
-        return BrowserToolPlaceholder
-
-
-# Dynamically set BrowserTool
-# BrowserTool = _import_browser_tool()
+BrowserTool = _import_browser_tool()
 
 # Export all tools (including optional ones that might be None)
 __all__ = [
@@ -124,8 +124,7 @@ __all__ = [
     'WebSearch',
     'WebFetch',
     'Vision',
-    # Optional tools (may be None if dependencies not available)
-    # 'BrowserTool'
+    'BrowserTool',
 ]
 
 """

agent/tools/browser/__init__.py

@@ -0,0 +1,3 @@
+from agent.tools.browser.browser_tool import BrowserTool
+
+__all__ = ["BrowserTool"]

agent/tools/browser/browser_service.py

@@ -0,0 +1,708 @@
+"""
+Browser service - Playwright wrapper managing browser lifecycle and page operations.
+
+All Playwright calls run on a dedicated background thread so that callers from
+any worker thread can safely use the service.  An idle-timeout mechanism
+automatically shuts down the browser (and its thread) after a configurable
+period of inactivity to free resources.
+"""
+
+import os
+import sys
+import uuid
+import queue
+import threading
+from typing import Optional, Dict, Any, List, Callable
+
+from common.log import logger
+
+try:
+    from playwright.sync_api import sync_playwright, Browser, BrowserContext, Page, Playwright
+    _HAS_PLAYWRIGHT = True
+except ImportError:
+    _HAS_PLAYWRIGHT = False
+
+
+# ---------------------------------------------------------------------------
+# Snapshot DOM helpers
+# ---------------------------------------------------------------------------
+
+# Tags that typically carry useful content for an agent
+_INTERACTIVE_TAGS = {
+    "a", "button", "input", "textarea", "select", "option",
+    "label", "details", "summary",
+}
+_SEMANTIC_TAGS = {
+    "h1", "h2", "h3", "h4", "h5", "h6",
+    "p", "li", "td", "th", "caption", "figcaption", "blockquote", "pre", "code",
+    "nav", "main", "article", "section", "header", "footer", "form", "table",
+    "img", "video", "audio",
+}
+_KEEP_TAGS = _INTERACTIVE_TAGS | _SEMANTIC_TAGS
+
+_SNAPSHOT_JS = """
+() => {
+    const KEEP = new Set(%s);
+    const INTERACTIVE = new Set(%s);
+    const SKIP = new Set(["script","style","noscript","svg","path","meta","link","br","hr"]);
+    let refCounter = 0;
+    const refMap = {};
+
+    function visible(el) {
+        if (!(el instanceof HTMLElement)) return true;
+        const st = window.getComputedStyle(el);
+        if (st.display === "none" || st.visibility === "hidden") return false;
+        if (parseFloat(st.opacity) === 0) return false;
+        return true;
+    }
+
+    function walk(node) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            const t = node.textContent.trim();
+            return t ? t : null;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) return null;
+        const tag = node.tagName.toLowerCase();
+        if (SKIP.has(tag)) return null;
+        if (!visible(node)) return null;
+
+        const children = [];
+        for (const ch of node.childNodes) {
+            const r = walk(ch);
+            if (r !== null) {
+                if (typeof r === "string") children.push(r);
+                else children.push(r);
+            }
+        }
+
+        const keep = KEEP.has(tag);
+        if (!keep) {
+            // Unwrap: promote children
+            if (children.length === 0) return null;
+            if (children.length === 1) return children[0];
+            return children;
+        }
+
+        const obj = { tag };
+        if (INTERACTIVE.has(tag)) {
+            refCounter++;
+            obj.ref = refCounter;
+            refMap[refCounter] = node;
+        }
+
+        // Attributes
+        if (tag === "a" && node.href) obj.href = node.getAttribute("href");
+        if (tag === "img") {
+            obj.alt = node.alt || "";
+            obj.src = node.getAttribute("src") || "";
+        }
+        if (tag === "input" || tag === "textarea" || tag === "select") {
+            obj.type = node.type || "text";
+            obj.name = node.name || undefined;
+            obj.value = node.value || undefined;
+            obj.placeholder = node.placeholder || undefined;
+            if (node.disabled) obj.disabled = true;
+            if (tag === "input" && node.type === "checkbox") obj.checked = node.checked;
+        }
+        if (tag === "button") {
+            if (node.disabled) obj.disabled = true;
+        }
+        if (tag === "option") {
+            obj.value = node.value;
+            if (node.selected) obj.selected = true;
+        }
+        if (tag === "label" && node.htmlFor) obj.for = node.htmlFor;
+
+        // Role / aria-label
+        const role = node.getAttribute("role");
+        if (role) obj.role = role;
+        const ariaLabel = node.getAttribute("aria-label");
+        if (ariaLabel) obj.ariaLabel = ariaLabel;
+
+        // Children
+        if (children.length === 1 && typeof children[0] === "string") {
+            obj.text = children[0];
+        } else if (children.length > 0) {
+            obj.children = children;
+        }
+
+        return obj;
+    }
+
+    // Store refMap on window for later use by click/fill actions
+    const result = walk(document.body);
+    window.__cowRefMap = refMap;
+    return { tree: result, refCount: refCounter };
+}
+""" % (
+    str(list(_KEEP_TAGS)),
+    str(list(_INTERACTIVE_TAGS)),
+)
+
+
+def _should_use_headless() -> bool:
+    """Decide headless mode: headless on Linux servers without display, headed elsewhere."""
+    if sys.platform in ("win32", "darwin"):
+        return False
+    # Linux: check for display
+    if os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"):
+        return False
+    return True
+
+
+def _flatten_tree(node, indent=0) -> List[str]:
+    """Convert snapshot tree to compact text lines for LLM consumption."""
+    if node is None:
+        return []
+    if isinstance(node, str):
+        return [" " * indent + node]
+    if isinstance(node, list):
+        lines = []
+        for child in node:
+            lines.extend(_flatten_tree(child, indent))
+        return lines
+    if not isinstance(node, dict):
+        return []
+
+    tag = node.get("tag", "?")
+    ref = node.get("ref")
+    parts = [tag]
+    if ref:
+        parts[0] = f"[{ref}] {tag}"
+
+    # Inline attributes
+    for attr in ("type", "name", "href", "alt", "role", "ariaLabel", "placeholder", "value"):
+        val = node.get(attr)
+        if val:
+            # Truncate long values
+            s = str(val)
+            if len(s) > 80:
+                s = s[:77] + "..."
+            parts.append(f'{attr}="{s}"')
+
+    for flag in ("disabled", "checked", "selected"):
+        if node.get(flag):
+            parts.append(flag)
+
+    prefix = " " * indent
+    header = prefix + " ".join(parts)
+
+    text = node.get("text")
+    if text:
+        # Truncate long text
+        if len(text) > 120:
+            text = text[:117] + "..."
+        header += f": {text}"
+
+    lines = [header]
+    children = node.get("children", [])
+    for child in children:
+        lines.extend(_flatten_tree(child, indent + 2))
+    return lines
+
+
+class BrowserService:
+    """Manages a Playwright browser on a dedicated background thread.
+
+    All Playwright operations are dispatched to a single long-lived thread via
+    a task queue.  Callers from *any* worker thread can use the public API
+    safely.  An idle timer automatically shuts the browser down after
+    ``idle_timeout`` seconds of inactivity (default 300 = 5 min).
+    """
+
+    _IDLE_TIMEOUT_DEFAULT = 300  # seconds
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        self._config = config or {}
+        self._headless: Optional[bool] = None
+        self._screenshot_dir: Optional[str] = None
+
+        # Background thread state
+        self._thread: Optional[threading.Thread] = None
+        self._task_queue: queue.Queue = queue.Queue()
+        self._lock = threading.Lock()
+        self._alive = False
+        self._ready = threading.Event()
+
+        # Playwright objects (only accessed on the background thread)
+        self._playwright = None
+        self._browser = None
+        self._context = None
+        self._page = None
+
+        # Idle auto-release
+        idle_cfg = self._config.get("idle_timeout")
+        self._idle_timeout: float = float(idle_cfg) if idle_cfg is not None else self._IDLE_TIMEOUT_DEFAULT
+        self._idle_timer: Optional[threading.Timer] = None
+
+    # ------------------------------------------------------------------
+    # Background-thread lifecycle
+    # ------------------------------------------------------------------
+
+    def _start_thread(self):
+        """Start the dedicated Playwright thread if not already running."""
+        with self._lock:
+            if self._alive and self._thread and self._thread.is_alive():
+                return
+            # Wait for old thread to fully exit before creating a new one
+            old = self._thread
+            if old and old.is_alive():
+                old.join(timeout=5)
+            # Fresh queue to avoid stale sentinels from a previous close()
+            self._task_queue = queue.Queue()
+            self._alive = True
+            self._ready = threading.Event()
+            self._thread = threading.Thread(target=self._run_loop, daemon=True, name="BrowserThread")
+            self._thread.start()
+            # Block until browser is ready (or failed)
+            self._ready.wait(timeout=30)
+
+    def _run_loop(self):
+        """Event loop running on the dedicated thread. Processes tasks until stopped."""
+        logger.info("[Browser] Background thread started")
+        try:
+            self._launch_browser()
+        except Exception as e:
+            logger.error(f"[Browser] Failed to launch browser: {e}")
+            self._alive = False
+            self._ready.set()
+            self._drain_queue(RuntimeError(f"Browser launch failed: {e}"))
+            return
+        self._ready.set()
+
+        while self._alive:
+            try:
+                task = self._task_queue.get(timeout=1.0)
+            except queue.Empty:
+                continue
+            if task is None:
+                break
+            fn, args, kwargs, result_slot = task
+            try:
+                result_slot["value"] = fn(*args, **kwargs)
+            except Exception as e:
+                result_slot["error"] = e
+            finally:
+                result_slot["event"].set()
+
+        self._shutdown_browser()
+        self._drain_queue(RuntimeError("Browser thread stopped"))
+        logger.info("[Browser] Background thread exited")
+
+    def _drain_queue(self, error: Exception):
+        """Unblock all callers waiting on the queue with an error."""
+        while True:
+            try:
+                task = self._task_queue.get_nowait()
+            except queue.Empty:
+                break
+            if task is None:
+                continue
+            _, _, _, result_slot = task
+            result_slot["error"] = error
+            result_slot["event"].set()
+
+    def _launch_browser(self):
+        """Launch Chromium on the background thread."""
+        if self._headless is None:
+            headless_cfg = self._config.get("headless")
+            self._headless = headless_cfg if headless_cfg is not None else _should_use_headless()
+
+        launch_args = ["--disable-dev-shm-usage"]
+        if self._headless:
+            launch_args.append("--no-sandbox")
+
+        extra_args = self._config.get("launch_args", [])
+        if extra_args:
+            launch_args.extend(extra_args)
+
+        viewport_w = self._config.get("viewport_width", 1280)
+        viewport_h = self._config.get("viewport_height", 720)
+
+        self._playwright = sync_playwright().start()
+        logger.info(f"[Browser] Launching Chromium (headless={self._headless})")
+        self._browser = self._playwright.chromium.launch(
+            headless=self._headless,
+            args=launch_args,
+        )
+        self._context = self._browser.new_context(
+            viewport={"width": viewport_w, "height": viewport_h},
+            user_agent=(
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/131.0.0.0 Safari/537.36"
+            ),
+        )
+        self._page = self._context.new_page()
+        logger.info("[Browser] Browser ready")
+
+    def _shutdown_browser(self):
+        """Shut down all Playwright resources on the background thread."""
+        self._cancel_idle_timer()
+        for obj, label in [
+            (self._context, "context"),
+            (self._browser, "browser"),
+        ]:
+            try:
+                if obj:
+                    obj.close()
+            except Exception as e:
+                logger.debug(f"[Browser] {label} close error: {e}")
+        try:
+            if self._playwright:
+                self._playwright.stop()
+        except Exception as e:
+            logger.debug(f"[Browser] playwright stop error: {e}")
+        self._page = None
+        self._context = None
+        self._browser = None
+        self._playwright = None
+        logger.info("[Browser] Browser closed")
+
+    def _submit(self, fn: Callable, *args, **kwargs):
+        """Submit *fn* to the background thread and block until it completes."""
+        self._start_thread()
+
+        if not self._alive:
+            raise RuntimeError("Browser is not available")
+
+        self._reset_idle_timer()
+
+        result_slot: Dict[str, Any] = {"event": threading.Event()}
+        self._task_queue.put((fn, args, kwargs, result_slot))
+
+        # Timeout prevents permanent hang if the background thread crashes
+        completed = result_slot["event"].wait(timeout=120)
+        if not completed:
+            raise TimeoutError("Browser operation timed out (120s)")
+
+        if "error" in result_slot:
+            raise result_slot["error"]
+        return result_slot.get("value")
+
+    # ------------------------------------------------------------------
+    # Idle auto-release
+    # ------------------------------------------------------------------
+
+    def _reset_idle_timer(self):
+        self._cancel_idle_timer()
+        if self._idle_timeout > 0:
+            self._idle_timer = threading.Timer(self._idle_timeout, self._on_idle_timeout)
+            self._idle_timer.daemon = True
+            self._idle_timer.start()
+
+    def _cancel_idle_timer(self):
+        if self._idle_timer:
+            self._idle_timer.cancel()
+            self._idle_timer = None
+
+    def _on_idle_timeout(self):
+        logger.info(f"[Browser] Idle for {self._idle_timeout}s, auto-releasing browser")
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Public lifecycle
+    # ------------------------------------------------------------------
+
+    def close(self):
+        """Shut down browser and background thread (safe from any thread)."""
+        self._cancel_idle_timer()
+        with self._lock:
+            if not self._alive:
+                return
+            self._alive = False
+            t = self._thread
+        if self._task_queue is not None:
+            self._task_queue.put(None)
+        if t is not None and t.is_alive():
+            t.join(timeout=10)
+        with self._lock:
+            self._thread = None
+
+    # ------------------------------------------------------------------
+    # Actions  (each method is dispatched to the background thread)
+    # ------------------------------------------------------------------
+
+    def navigate(self, url: str, timeout: int = 30000) -> Dict[str, Any]:
+        return self._submit(self._do_navigate, url, timeout)
+
+    def _do_navigate(self, url: str, timeout: int) -> Dict[str, Any]:
+        page = self._page
+        try:
+            resp = page.goto(url, wait_until="domcontentloaded", timeout=timeout)
+            status = resp.status if resp else None
+        except Exception as e:
+            return {"error": f"Navigation failed: {e}"}
+
+        try:
+            page.wait_for_load_state("networkidle", timeout=8000)
+        except Exception:
+            pass
+        page.wait_for_timeout(500)
+
+        try:
+            title = page.title()
+        except Exception:
+            title = ""
+        try:
+            current_url = page.url
+        except Exception:
+            current_url = url
+
+        return {"url": current_url, "title": title, "status": status}
+
+    def snapshot(self, selector: Optional[str] = None) -> str:
+        return self._submit(self._do_snapshot, selector)
+
+    def _do_snapshot(self, selector: Optional[str] = None) -> str:
+        page = self._page
+        try:
+            result = page.evaluate(_SNAPSHOT_JS)
+        except Exception as e:
+            return f"[Snapshot error: {e}]"
+
+        tree = result.get("tree")
+        ref_count = result.get("refCount", 0)
+        lines = _flatten_tree(tree)
+
+        try:
+            title = page.title()
+        except Exception:
+            title = ""
+        try:
+            url = page.url
+        except Exception:
+            url = ""
+
+        header = f"Page: {title}  ({url})\nInteractive elements: {ref_count}\n---"
+        body = "\n".join(lines)
+
+        max_chars = self._config.get("snapshot_max_chars", 30000)
+        if len(body) > max_chars:
+            body = body[:max_chars] + "\n... [snapshot truncated]"
+
+        return f"{header}\n{body}"
+
+    def screenshot(self, full_page: bool = False, cwd: str = "") -> str:
+        return self._submit(self._do_screenshot, full_page, cwd)
+
+    def _do_screenshot(self, full_page: bool = False, cwd: str = "") -> str:
+        page = self._page
+        save_dir = self._get_screenshot_dir(cwd)
+        filename = f"screenshot_{uuid.uuid4().hex[:8]}.png"
+        filepath = os.path.join(save_dir, filename)
+        page.screenshot(path=filepath, full_page=full_page)
+        logger.info(f"[Browser] Screenshot saved: {filepath}")
+        return filepath
+
+    def click(self, ref: Optional[int] = None, selector: Optional[str] = None,
+              timeout: int = 5000) -> Dict[str, Any]:
+        return self._submit(self._do_click, ref, selector, timeout)
+
+    def _do_click(self, ref, selector, timeout) -> Dict[str, Any]:
+        page = self._page
+        try:
+            if ref is not None:
+                result = page.evaluate(f"""
+                    () => {{
+                        const el = window.__cowRefMap && window.__cowRefMap[{ref}];
+                        if (!el) return {{ error: "ref {ref} not found. Run snapshot first." }};
+                        el.click();
+                        return {{ clicked: true, tag: el.tagName.toLowerCase() }};
+                    }}
+                """)
+                if result.get("error"):
+                    return result
+                page.wait_for_timeout(500)
+                return result
+            elif selector:
+                page.click(selector, timeout=timeout)
+                return {"clicked": True, "selector": selector}
+            else:
+                return {"error": "Provide either ref (from snapshot) or selector"}
+        except Exception as e:
+            return {"error": f"Click failed: {e}"}
+
+    def fill(self, text: str, ref: Optional[int] = None,
+             selector: Optional[str] = None, timeout: int = 5000) -> Dict[str, Any]:
+        return self._submit(self._do_fill, text, ref, selector, timeout)
+
+    def _do_fill(self, text, ref, selector, timeout) -> Dict[str, Any]:
+        page = self._page
+        try:
+            if ref is not None:
+                result = page.evaluate(f"""
+                    () => {{
+                        const el = window.__cowRefMap && window.__cowRefMap[{ref}];
+                        if (!el) return {{ error: "ref {ref} not found. Run snapshot first." }};
+                        el.focus();
+                        el.value = "";
+                        return {{ tag: el.tagName.toLowerCase(), name: el.name || "" }};
+                    }}
+                """)
+                if result.get("error"):
+                    return result
+                page.keyboard.type(text)
+                return {"filled": True, "ref": ref, "text": text}
+            elif selector:
+                page.fill(selector, text, timeout=timeout)
+                return {"filled": True, "selector": selector, "text": text}
+            else:
+                return {"error": "Provide either ref (from snapshot) or selector"}
+        except Exception as e:
+            return {"error": f"Fill failed: {e}"}
+
+    def select(self, value: str, ref: Optional[int] = None,
+               selector: Optional[str] = None, timeout: int = 5000) -> Dict[str, Any]:
+        return self._submit(self._do_select, value, ref, selector, timeout)
+
+    def _do_select(self, value, ref, selector, timeout) -> Dict[str, Any]:
+        page = self._page
+        try:
+            if ref is not None:
+                result = page.evaluate(f"""
+                    () => {{
+                        const el = window.__cowRefMap && window.__cowRefMap[{ref}];
+                        if (!el || el.tagName.toLowerCase() !== "select")
+                            return {{ error: "ref {ref} is not a <select> element" }};
+                        el.value = {repr(value)};
+                        el.dispatchEvent(new Event("change", {{ bubbles: true }}));
+                        return {{ selected: true, value: el.value }};
+                    }}
+                """)
+                return result
+            elif selector:
+                page.select_option(selector, value, timeout=timeout)
+                return {"selected": True, "selector": selector, "value": value}
+            else:
+                return {"error": "Provide either ref (from snapshot) or selector"}
+        except Exception as e:
+            return {"error": f"Select failed: {e}"}
+
+    def scroll(self, direction: str = "down", amount: int = 500) -> Dict[str, Any]:
+        return self._submit(self._do_scroll, direction, amount)
+
+    def _do_scroll(self, direction, amount) -> Dict[str, Any]:
+        page = self._page
+        delta_map = {
+            "down": (0, amount),
+            "up": (0, -amount),
+            "right": (amount, 0),
+            "left": (-amount, 0),
+        }
+        dx, dy = delta_map.get(direction, (0, amount))
+        try:
+            page.mouse.wheel(dx, dy)
+            page.wait_for_timeout(300)
+            scroll_info = page.evaluate("""
+                () => ({
+                    scrollX: window.scrollX,
+                    scrollY: window.scrollY,
+                    scrollHeight: document.documentElement.scrollHeight,
+                    clientHeight: document.documentElement.clientHeight
+                })
+            """)
+            return {"scrolled": direction, "amount": amount, **scroll_info}
+        except Exception as e:
+            return {"error": f"Scroll failed: {e}"}
+
+    def wait(self, selector: Optional[str] = None, timeout: int = 5000,
+             state: str = "visible") -> Dict[str, Any]:
+        return self._submit(self._do_wait, selector, timeout, state)
+
+    def _do_wait(self, selector, timeout, state) -> Dict[str, Any]:
+        page = self._page
+        try:
+            if selector:
+                page.wait_for_selector(selector, timeout=timeout, state=state)
+                return {"waited": True, "selector": selector, "state": state}
+            else:
+                page.wait_for_timeout(timeout)
+                return {"waited": True, "timeout_ms": timeout}
+        except Exception as e:
+            return {"error": f"Wait failed: {e}"}
+
+    def go_back(self) -> Dict[str, Any]:
+        return self._submit(self._do_go_back)
+
+    def _do_go_back(self) -> Dict[str, Any]:
+        page = self._page
+        try:
+            page.go_back(wait_until="domcontentloaded", timeout=10000)
+            try:
+                title = page.title()
+            except Exception:
+                title = ""
+            try:
+                url = page.url
+            except Exception:
+                url = ""
+            return {"url": url, "title": title}
+        except Exception as e:
+            return {"error": f"Go back failed: {e}"}
+
+    def go_forward(self) -> Dict[str, Any]:
+        return self._submit(self._do_go_forward)
+
+    def _do_go_forward(self) -> Dict[str, Any]:
+        page = self._page
+        try:
+            page.go_forward(wait_until="domcontentloaded", timeout=10000)
+            try:
+                title = page.title()
+            except Exception:
+                title = ""
+            try:
+                url = page.url
+            except Exception:
+                url = ""
+            return {"url": url, "title": title}
+        except Exception as e:
+            return {"error": f"Go forward failed: {e}"}
+
+    def get_text(self, selector: str) -> Dict[str, Any]:
+        return self._submit(self._do_get_text, selector)
+
+    def _do_get_text(self, selector) -> Dict[str, Any]:
+        page = self._page
+        try:
+            text = page.text_content(selector, timeout=5000)
+            return {"text": text or ""}
+        except Exception as e:
+            return {"error": f"Get text failed: {e}"}
+
+    def evaluate(self, script: str) -> Dict[str, Any]:
+        return self._submit(self._do_evaluate, script)
+
+    def _do_evaluate(self, script) -> Dict[str, Any]:
+        page = self._page
+        try:
+            result = page.evaluate(script)
+            return {"result": result}
+        except Exception as e:
+            return {"error": f"Evaluate failed: {e}"}
+
+    def press(self, key: str) -> Dict[str, Any]:
+        return self._submit(self._do_press, key)
+
+    def _do_press(self, key) -> Dict[str, Any]:
+        page = self._page
+        try:
+            page.keyboard.press(key)
+            page.wait_for_timeout(300)
+            return {"pressed": key}
+        except Exception as e:
+            return {"error": f"Press failed: {e}"}
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _get_screenshot_dir(self, cwd: str = "") -> str:
+        if self._screenshot_dir and os.path.isdir(self._screenshot_dir):
+            return self._screenshot_dir
+        base = cwd or os.getcwd()
+        d = os.path.join(base, "tmp")
+        os.makedirs(d, exist_ok=True)
+        self._screenshot_dir = d
+        return d

agent/tools/browser/browser_tool.py

@@ -0,0 +1,290 @@
+"""
+Browser tool - Control a Chromium browser for web navigation and interaction.
+
+Uses Playwright under the hood. Browser instance is lazily started on first
+use, reused across tool calls within the same session, and cleaned up via
+close().
+"""
+
+import json
+import os
+from typing import Dict, Any, Optional
+
+from agent.tools.base_tool import BaseTool, ToolResult
+from agent.tools.browser.browser_service import BrowserService
+from common.log import logger
+
+
+class BrowserTool(BaseTool):
+    """Single tool exposing all browser actions via an 'action' parameter."""
+
+    name: str = "browser"
+    description: str = (
+        "Control a browser to navigate web pages, interact with elements, and extract content. "
+        "Actions: navigate, snapshot, click, fill, select, scroll, screenshot, wait, back, forward, "
+        "get_text, press, evaluate.\n\n"
+        "Workflow: navigate (auto-includes snapshot with element refs) → click/fill/select by ref → snapshot to verify.\n\n"
+        "Use snapshot as the primary way to read pages. Use screenshot + send to show key results to the user. "
+        "For login/CAPTCHA/authorization etc., screenshot and ask the user for help."
+    )
+
+    params: dict = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "description": (
+                    "The browser action to perform. One of: "
+                    "navigate, snapshot, click, fill, select, scroll, "
+                    "screenshot, wait, back, forward, get_text, press, evaluate"
+                ),
+                "enum": [
+                    "navigate", "snapshot", "click", "fill", "select", "scroll",
+                    "screenshot", "wait", "back", "forward", "get_text", "press",
+                    "evaluate"
+                ]
+            },
+            "url": {
+                "type": "string",
+                "description": "URL to navigate to (for 'navigate' action)"
+            },
+            "ref": {
+                "type": "integer",
+                "description": "Element ref number from snapshot (for click/fill/select)"
+            },
+            "selector": {
+                "type": "string",
+                "description": "CSS selector as fallback when ref is unavailable (for click/fill/select/wait/get_text)"
+            },
+            "text": {
+                "type": "string",
+                "description": "Text to type (for 'fill' action)"
+            },
+            "value": {
+                "type": "string",
+                "description": "Option value (for 'select' action)"
+            },
+            "key": {
+                "type": "string",
+                "description": "Key to press, e.g. Enter, Tab, Escape (for 'press' action)"
+            },
+            "direction": {
+                "type": "string",
+                "description": "Scroll direction: up, down, left, right (for 'scroll' action, default: down)"
+            },
+            "script": {
+                "type": "string",
+                "description": "JavaScript code to execute (for 'evaluate' action)"
+            },
+            "full_page": {
+                "type": "boolean",
+                "description": "Capture full page screenshot (for 'screenshot' action, default: false)"
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Timeout in milliseconds (optional, default varies by action)"
+            }
+        },
+        "required": ["action"]
+    }
+
+    _shared_service: Optional[BrowserService] = None
+
+    def __init__(self, config: dict = None):
+        self.config = config or {}
+        self.cwd = self.config.get("cwd", os.getcwd())
+        self._service: Optional[BrowserService] = None
+
+    def _get_service(self) -> BrowserService:
+        """Get or create the browser service, sharing across copies."""
+        if self._service is not None:
+            return self._service
+
+        # Reuse shared service across tool copies within the same session
+        if BrowserTool._shared_service is not None:
+            self._service = BrowserTool._shared_service
+            return self._service
+
+        self._service = BrowserService(self.config)
+        BrowserTool._shared_service = self._service
+        return self._service
+
+    def execute(self, args: Dict[str, Any]) -> ToolResult:
+        action = args.get("action", "").strip().lower()
+        if not action:
+            return ToolResult.fail("Error: 'action' parameter is required")
+
+        handler = self._ACTION_MAP.get(action)
+        if not handler:
+            valid = ", ".join(sorted(self._ACTION_MAP.keys()))
+            return ToolResult.fail(f"Unknown action '{action}'. Valid actions: {valid}")
+
+        try:
+            return handler(self, args)
+        except Exception as e:
+            logger.error(f"[Browser] Action '{action}' error: {e}")
+            return ToolResult.fail(f"Browser error ({action}): {e}")
+
+    # ------------------------------------------------------------------
+    # Action handlers
+    # ------------------------------------------------------------------
+
+    def _do_navigate(self, args: Dict[str, Any]) -> ToolResult:
+        url = args.get("url", "").strip()
+        if not url:
+            return ToolResult.fail("Error: 'url' is required for navigate action")
+        if not url.startswith(("http://", "https://")):
+            url = "https://" + url
+        timeout = args.get("timeout", 30000)
+        service = self._get_service()
+        result = service.navigate(url, timeout=timeout)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        # Auto-snapshot after navigation so the agent gets page content in one call
+        snapshot_text = service.snapshot()
+        return ToolResult.success(
+            f"Navigated to: {result['url']}\nTitle: {result['title']}\nStatus: {result['status']}\n\n"
+            f"--- Page Snapshot ---\n{snapshot_text}"
+        )
+
+    def _do_snapshot(self, args: Dict[str, Any]) -> ToolResult:
+        selector = args.get("selector")
+        text = self._get_service().snapshot(selector=selector)
+        return ToolResult.success(text)
+
+    def _do_click(self, args: Dict[str, Any]) -> ToolResult:
+        ref = args.get("ref")
+        selector = args.get("selector")
+        timeout = args.get("timeout", 5000)
+        result = self._get_service().click(ref=ref, selector=selector, timeout=timeout)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Clicked successfully. Use 'snapshot' to see updated page.")
+
+    def _do_fill(self, args: Dict[str, Any]) -> ToolResult:
+        text = args.get("text", "")
+        ref = args.get("ref")
+        selector = args.get("selector")
+        timeout = args.get("timeout", 5000)
+        if not text and text != "":
+            return ToolResult.fail("Error: 'text' is required for fill action")
+        result = self._get_service().fill(text, ref=ref, selector=selector, timeout=timeout)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Filled text into element. Use 'snapshot' to verify.")
+
+    def _do_select(self, args: Dict[str, Any]) -> ToolResult:
+        value = args.get("value", "")
+        ref = args.get("ref")
+        selector = args.get("selector")
+        timeout = args.get("timeout", 5000)
+        if not value:
+            return ToolResult.fail("Error: 'value' is required for select action")
+        result = self._get_service().select(value, ref=ref, selector=selector, timeout=timeout)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Selected option '{value}'.")
+
+    def _do_scroll(self, args: Dict[str, Any]) -> ToolResult:
+        direction = args.get("direction", "down")
+        amount = args.get("timeout", 500)  # reuse timeout field or default
+        if "amount" in args:
+            amount = args["amount"]
+        result = self._get_service().scroll(direction=direction, amount=amount)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        pos = f"scrollY={result.get('scrollY', '?')}/{result.get('scrollHeight', '?')}"
+        return ToolResult.success(f"Scrolled {direction}. Position: {pos}")
+
+    def _do_screenshot(self, args: Dict[str, Any]) -> ToolResult:
+        full_page = args.get("full_page", False)
+        filepath = self._get_service().screenshot(full_page=full_page, cwd=self.cwd)
+        return ToolResult.success(f"Screenshot saved to: {filepath}")
+
+    def _do_wait(self, args: Dict[str, Any]) -> ToolResult:
+        selector = args.get("selector")
+        timeout = args.get("timeout", 5000)
+        result = self._get_service().wait(selector=selector, timeout=timeout)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Wait completed.")
+
+    def _do_back(self, args: Dict[str, Any]) -> ToolResult:
+        result = self._get_service().go_back()
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Navigated back to: {result['url']}")
+
+    def _do_forward(self, args: Dict[str, Any]) -> ToolResult:
+        result = self._get_service().go_forward()
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Navigated forward to: {result['url']}")
+
+    def _do_get_text(self, args: Dict[str, Any]) -> ToolResult:
+        selector = args.get("selector", "").strip()
+        if not selector:
+            return ToolResult.fail("Error: 'selector' is required for get_text action")
+        result = self._get_service().get_text(selector)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(result["text"])
+
+    def _do_press(self, args: Dict[str, Any]) -> ToolResult:
+        key = args.get("key", "").strip()
+        if not key:
+            return ToolResult.fail("Error: 'key' is required for press action")
+        result = self._get_service().press(key)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        return ToolResult.success(f"Pressed key: {key}")
+
+    def _do_evaluate(self, args: Dict[str, Any]) -> ToolResult:
+        script = args.get("script", "").strip()
+        if not script:
+            return ToolResult.fail("Error: 'script' is required for evaluate action")
+        result = self._get_service().evaluate(script)
+        if "error" in result:
+            return ToolResult.fail(result["error"])
+        val = result.get("result")
+        if isinstance(val, (dict, list)):
+            return ToolResult.success(json.dumps(val, ensure_ascii=False, indent=2))
+        return ToolResult.success(str(val) if val is not None else "(no return value)")
+
+    # Action dispatch table
+    _ACTION_MAP = {
+        "navigate": _do_navigate,
+        "snapshot": _do_snapshot,
+        "click": _do_click,
+        "fill": _do_fill,
+        "select": _do_select,
+        "scroll": _do_scroll,
+        "screenshot": _do_screenshot,
+        "wait": _do_wait,
+        "back": _do_back,
+        "forward": _do_forward,
+        "get_text": _do_get_text,
+        "press": _do_press,
+        "evaluate": _do_evaluate,
+    }
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def copy(self):
+        """Share browser instance across tool copies (avoids re-launching)."""
+        new_tool = BrowserTool(self.config)
+        new_tool.model = self.model
+        new_tool.context = getattr(self, "context", None)
+        new_tool.cwd = self.cwd
+        new_tool._service = self._service
+        return new_tool
+
+    def close(self):
+        """Release browser resources."""
+        if self._service:
+            self._service.close()
+            self._service = None
+        BrowserTool._shared_service = None
+        logger.info("[Browser] BrowserTool closed")

agent/tools/browser_tool.py

@@ -1,18 +0,0 @@
-def copy(self):
-    """
-    Special copy method for browser tool to avoid recreating browser instance.
-    
-    :return: A new instance with shared browser reference but unique model
-    """
-    new_tool = self.__class__()
-    
-    # Copy essential attributes
-    new_tool.model = self.model
-    new_tool.context = getattr(self, 'context', None)
-    new_tool.config = getattr(self, 'config', None)
-    
-    # Share the browser instance instead of creating a new one
-    if hasattr(self, 'browser'):
-        new_tool.browser = self.browser
-    
-    return new_tool 

agent/tools/send/send.py

@@ -98,7 +98,18 @@ class Send(BaseTool):
             "size_formatted": self._format_size(file_size),
             "message": message or f"正在发送 {file_name}"
         }
-        
+
+        try:
+            from common.cloud_client import get_website_base_url, copy_send_file
+
+            # Do nothing when in local env
+            if get_website_base_url():
+                url = copy_send_file(absolute_path, self.cwd)
+                if url:
+                    result["url"] = url
+        except Exception:
+            pass
+
         return ToolResult.success(result)
     
     def _resolve_path(self, path: str) -> str:

agent/tools/tool_manager.py

@@ -84,11 +84,11 @@ class ToolManager:
                                 except ImportError as e:
                                     # Handle missing dependencies with helpful messages
                                     error_msg = str(e)
-                                    if "browser-use" in error_msg or "browser_use" in error_msg:
+                                    if "playwright" in error_msg:
                                         logger.warning(
                                             f"[ToolManager] Browser tool not loaded - missing dependencies.\n"
                                             f"  To enable browser tool, run:\n"
-                                            f"    pip install browser-use markdownify playwright\n"
+                                            f"    pip install playwright\n"
                                             f"    playwright install chromium"
                                         )
                                     elif "markdownify" in error_msg:
@@ -154,11 +154,11 @@ class ToolManager:
                             except ImportError as e:
                                 # Handle missing dependencies with helpful messages
                                 error_msg = str(e)
-                                if "browser-use" in error_msg or "browser_use" in error_msg:
+                                if "playwright" in error_msg:
                                     logger.warning(
                                         f"[ToolManager] Browser tool not loaded - missing dependencies.\n"
                                         f"  To enable browser tool, run:\n"
-                                        f"    pip install browser-use markdownify playwright\n"
+                                        f"    pip install playwright\n"
                                         f"    playwright install chromium"
                                     )
                                 elif "markdownify" in error_msg:
@@ -197,7 +197,7 @@ class ToolManager:
                         logger.warning(
                             f"[ToolManager] Browser tool is configured but not loaded.\n"
                             f"  To enable browser tool, run:\n"
-                            f"    pip install browser-use markdownify playwright\n"
+                            f"    pip install playwright\n"
                             f"    playwright install chromium"
                         )
                     elif tool_name == "google_search":

agent/tools/vision/vision.py

@@ -167,7 +167,7 @@ class Vision(BaseTool):
 
     @staticmethod
     def _maybe_compress(path: str) -> str:
-        """Compress image if larger than threshold; return path to use."""
+        """Compress image to under COMPRESS_THRESHOLD with max long-edge 1536px."""
         file_size = os.path.getsize(path)
         if file_size <= COMPRESS_THRESHOLD:
             return path
@@ -175,27 +175,47 @@ class Vision(BaseTool):
         tmp = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False)
         tmp.close()
 
-        try:
-            # macOS: use sips
-            subprocess.run(
-                ["sips", "-Z", "800", path, "--out", tmp.name],
-                capture_output=True, check=True,
-            )
-            logger.debug(f"[Vision] Compressed image ({file_size // 1024}KB -> {os.path.getsize(tmp.name) // 1024}KB)")
-            return tmp.name
-        except (FileNotFoundError, subprocess.CalledProcessError):
-            pass
+        def _try_sips(max_dim: str, quality: str) -> bool:
+            try:
+                subprocess.run(
+                    ["sips", "-Z", max_dim, "-s", "formatOptions", quality,
+                     path, "--out", tmp.name],
+                    capture_output=True, check=True,
+                )
+                return True
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                return False
 
-        try:
-            # Linux: use ImageMagick convert
-            subprocess.run(
-                ["convert", path, "-resize", "800x800>", tmp.name],
-                capture_output=True, check=True,
-            )
-            logger.debug(f"[Vision] Compressed image ({file_size // 1024}KB -> {os.path.getsize(tmp.name) // 1024}KB)")
+        def _try_convert(max_dim: str, quality: str) -> bool:
+            try:
+                subprocess.run(
+                    ["convert", path, "-resize", f"{max_dim}x{max_dim}>",
+                     "-quality", quality, tmp.name],
+                    capture_output=True, check=True,
+                )
+                return True
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                return False
+
+        attempts = [
+            ("1536", "85"),
+            ("1536", "70"),
+            ("1536", "50"),
+        ]
+
+        for max_dim, quality in attempts:
+            ok = _try_sips(max_dim, quality) or _try_convert(max_dim, quality)
+            if not ok:
+                continue
+            new_size = os.path.getsize(tmp.name)
+            logger.debug(f"[Vision] Compressed image "
+                         f"({file_size // 1024}KB -> {new_size // 1024}KB, "
+                         f"max_dim={max_dim}, q={quality})")
+            if new_size <= COMPRESS_THRESHOLD:
+                return tmp.name
+
+        if os.path.exists(tmp.name) and os.path.getsize(tmp.name) > 0:
             return tmp.name
-        except (FileNotFoundError, subprocess.CalledProcessError):
-            pass
 
         os.remove(tmp.name)
         return path

bridge/agent_bridge.py

@@ -74,7 +74,7 @@ class AgentLLMModel(LLMModel):
         ("qwen", const.QWEN_DASHSCOPE), ("qwq", const.QWEN_DASHSCOPE), ("qvq", const.QWEN_DASHSCOPE),
         ("gemini", const.GEMINI), ("glm", const.ZHIPU_AI), ("claude", const.CLAUDEAPI),
         ("moonshot", const.MOONSHOT), ("kimi", const.MOONSHOT),
-        ("doubao", const.DOUBAO),
+        ("doubao", const.DOUBAO), ("deepseek", const.DEEPSEEK),
     ]
 
     def __init__(self, bridge: Bridge, bot_type: str = "chat"):
@@ -115,8 +115,8 @@ class AgentLLMModel(LLMModel):
             return const.QWEN_DASHSCOPE
         if model_name in [const.MOONSHOT, "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]:
             return const.MOONSHOT
-        if model_name in [const.DEEPSEEK_CHAT, const.DEEPSEEK_REASONER]:
-            return const.OPENAI
+        if conf().get("bot_type") == "modelscope":
+            return const.MODELSCOPE
         for prefix, btype in self._MODEL_PREFIX_MAP:
             if model_name.startswith(prefix):
                 return btype
@@ -273,10 +273,13 @@ class AgentBridge:
             tool_manager.load_tools()
             
             tools = []
+            workspace_dir = kwargs.get("workspace_dir")
             for tool_name in tool_manager.tool_classes.keys():
                 try:
                     tool = tool_manager.create_tool(tool_name)
                     if tool:
+                        if workspace_dir and hasattr(tool, 'cwd'):
+                            tool.cwd = workspace_dir
                         tools.append(tool)
                 except Exception as e:
                     logger.warning(f"[AgentBridge] Failed to load tool {tool_name}: {e}")

bridge/agent_initializer.py

@@ -366,7 +366,7 @@ class AgentInitializer:
 
                 if tool:
                     # Apply workspace config to file operation tools
-                    if tool_name in ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls', 'web_fetch']:
+                    if tool_name in ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls', 'web_fetch', 'send', 'browser']:
                         tool.config = file_config
                         tool.cwd = file_config.get("cwd", getattr(tool, 'cwd', None))
                         if 'memory_manager' in file_config:

bridge/bridge.py

@@ -61,6 +61,9 @@ class Bridge(object):
             if model_type and model_type.startswith("doubao"):
                 self.btype["chat"] = const.DOUBAO
 
+            if model_type and model_type.startswith("deepseek"):
+                self.btype["chat"] = const.DEEPSEEK
+
             if model_type in [const.MODELSCOPE]:
                 self.btype["chat"] = const.MODELSCOPE
             

channel/web/chat.html

@@ -166,8 +166,8 @@
                     <i class="fas fa-bars text-slate-600 dark:text-slate-300"></i>
                 </button>
 
-                <!-- Breadcrumb -->
-                <div class="flex items-center gap-2 text-sm min-w-0">
+                <!-- Breadcrumb (hidden on mobile) -->
+                <div class="hidden lg:flex items-center gap-2 text-sm min-w-0">
                     <span id="breadcrumb-group" class="text-slate-400 dark:text-slate-500 truncate" data-i18n="nav_chat">Chat</span>
                     <i class="fas fa-chevron-right text-[10px] text-slate-300 dark:text-slate-600"></i>
                     <span id="breadcrumb-page" class="font-medium text-slate-700 dark:text-slate-200 truncate" data-i18n="menu_chat">Chat</span>
@@ -270,7 +270,7 @@
                         <div class="max-w-3xl mx-auto">
                             <!-- Attachment preview bar -->
                             <div id="attachment-preview" class="attachment-preview hidden"></div>
-                            <div class="flex items-center gap-2">
+                            <div class="flex items-center gap-2 relative">
                                 <div class="flex items-center flex-shrink-0">
                                     <button id="new-chat-btn" class="w-9 h-10 flex items-center justify-center rounded-lg
                                                                      text-slate-400 hover:text-primary-500 hover:bg-primary-50 dark:hover:bg-primary-900/20
@@ -287,6 +287,7 @@
                                 </div>
                                 <input type="file" id="file-input" class="hidden" multiple
                                        accept="image/*,.pdf,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.txt,.csv,.json,.xml,.zip,.rar,.7z,.py,.js,.ts,.java,.c,.cpp,.go,.rs,.md">
+                                <div id="slash-menu" class="slash-menu hidden"></div>
                                 <textarea id="chat-input"
                                           class="flex-1 min-w-0 px-4 py-[10px] rounded-xl border border-slate-200 dark:border-slate-600
                                                  bg-slate-50 dark:bg-white/5 text-slate-800 dark:text-slate-100
@@ -295,7 +296,7 @@
                                                  text-sm leading-relaxed"
                                           rows="1"
                                           data-i18n-placeholder="input_placeholder"
-                                          placeholder="Type a message..."></textarea>
+                                          placeholder="Type a message, or press / for commands"></textarea>
                                 <button id="send-btn"
                                         class="flex-shrink-0 w-10 h-10 flex items-center justify-center rounded-lg
                                                bg-primary-400 text-white hover:bg-primary-500

channel/web/static/css/console.css

@@ -79,6 +79,11 @@
 .msg-content img { max-width: 100%; height: auto; border-radius: 8px; margin: 0.5em 0; }
 .msg-content a { color: #35A85B; text-decoration: underline; }
 .msg-content a:hover { color: #228547; }
+
+/* Overrides for user bubble (white text on green bg) */
+.user-bubble.msg-content a { color: #ffffff !important; text-decoration: underline; text-decoration-color: rgba(255,255,255,0.6); }
+.user-bubble.msg-content a:hover { color: #e0f5e8 !important; text-decoration-color: #e0f5e8; }
+.user-bubble.msg-content :not(pre) > code { background: rgba(255,255,255,0.2); color: #ffffff; }
 .msg-content hr { border: none; height: 1px; background: #e2e8f0; margin: 1.2em 0; }
 .dark .msg-content hr { background: rgba(255,255,255,0.1); }
 
@@ -446,3 +451,87 @@
     transform: translateY(-2px);
     box-shadow: 0 8px 25px -5px rgba(0, 0, 0, 0.1);
 }
+
+/* Slash Command Menu */
+.slash-menu {
+    position: absolute;
+    bottom: calc(100% + 6px);
+    left: 0;
+    right: 0;
+    max-height: 320px;
+    overflow-y: auto;
+    background: #fff;
+    border: 1px solid #e2e8f0;
+    border-radius: 12px;
+    box-shadow: 0 8px 30px -6px rgba(0, 0, 0, 0.1), 0 2px 8px -2px rgba(0, 0, 0, 0.04);
+    z-index: 50;
+    padding: 4px;
+    animation: slashMenuIn 0.15s ease-out;
+}
+.slash-menu.hidden { display: none; }
+
+@keyframes slashMenuIn {
+    from { opacity: 0; transform: translateY(6px); }
+    to   { opacity: 1; transform: translateY(0); }
+}
+
+.slash-menu-header {
+    padding: 6px 10px 4px;
+    font-size: 11px;
+    font-weight: 600;
+    color: #94a3b8;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.slash-menu-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 10px;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: background 0.12s ease;
+}
+.slash-menu-item:hover,
+.slash-menu-item.active {
+    background: #EDFDF3;
+}
+.slash-menu-item .cmd {
+    font-size: 13px;
+    font-weight: 500;
+    color: #334155;
+    font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, monospace;
+}
+.slash-menu-item.active .cmd {
+    color: #228547;
+}
+.slash-menu-item .desc {
+    font-size: 12px;
+    color: #94a3b8;
+    margin-left: 12px;
+    white-space: nowrap;
+}
+
+/* Dark mode */
+.dark .slash-menu {
+    background: #1A1A1A;
+    border-color: rgba(255, 255, 255, 0.1);
+    box-shadow: 0 8px 30px -6px rgba(0, 0, 0, 0.35), 0 2px 8px -2px rgba(0, 0, 0, 0.15);
+}
+.dark .slash-menu-header {
+    color: #64748b;
+}
+.dark .slash-menu-item:hover,
+.dark .slash-menu-item.active {
+    background: rgba(74, 190, 110, 0.1);
+}
+.dark .slash-menu-item .cmd {
+    color: #e2e8f0;
+}
+.dark .slash-menu-item.active .cmd {
+    color: #4ABE6E;
+}
+.dark .slash-menu-item .desc {
+    color: #64748b;
+}

channel/web/static/js/console.js

@@ -3,9 +3,9 @@
    ===================================================================== */
 
 // =====================================================================
-// Version — update this before each release
+// Version — fetched from backend (single source: /VERSION file)
 // =====================================================================
-const APP_VERSION = 'v2.0.4';
+let APP_VERSION = '';
 
 // =====================================================================
 // i18n
@@ -21,7 +21,7 @@ const I18N = {
         example_sys_title: '系统管理', example_sys_text: '帮我查看工作空间里有哪些文件',
         example_task_title: '技能系统', example_task_text: '查看所有支持的工具和技能',
         example_code_title: '编程助手', example_code_text: '帮我编写一个Python爬虫脚本',
-        input_placeholder: '输入消息...',
+        input_placeholder: '输入消息，或输入 / 使用指令',
         config_title: '配置管理', config_desc: '管理模型和 Agent 配置',
         config_model: '模型配置', config_agent: 'Agent 配置',
         config_channel: '通道配置',
@@ -56,6 +56,10 @@ const I18N = {
         weixin_scan_scanned: '已扫码，请在手机上确认', weixin_scan_expired: '二维码已过期，正在刷新...',
         weixin_scan_success: '登录成功，正在启动通道...', weixin_scan_fail: '获取二维码失败',
         weixin_qr_tip: '二维码约2分钟后过期',
+        wecom_scan_btn: '扫码创建企微机器人', wecom_scan_desc: '使用企业微信扫码，一键创建智能机器人',
+        wecom_scan_success: '创建成功，正在启动通道...',
+        wecom_scan_fail: '创建失败',
+        wecom_mode_scan: '扫码接入', wecom_mode_manual: '手动填写',
         tasks_title: '定时任务', tasks_desc: '查看和管理定时任务',
         tasks_coming: '即将推出', tasks_coming_desc: '定时任务管理功能即将在此提供',
         logs_title: '日志', logs_desc: '实时日志输出 (run.log)',
@@ -72,7 +76,7 @@ const I18N = {
         example_sys_title: 'System', example_sys_text: 'Show me the files in the workspace',
         example_task_title: 'Skills', example_task_text: 'Show current tools and skills',
         example_code_title: 'Coding', example_code_text: 'Write a Python web scraper script',
-        input_placeholder: 'Type a message...',
+        input_placeholder: 'Type a message, or press / for commands',
         config_title: 'Configuration', config_desc: 'Manage model and agent settings',
         config_model: 'Model Configuration', config_agent: 'Agent Configuration',
         config_channel: 'Channel Configuration',
@@ -107,6 +111,10 @@ const I18N = {
         weixin_scan_scanned: 'Scanned, please confirm on your phone', weixin_scan_expired: 'QR code expired, refreshing...',
         weixin_scan_success: 'Login successful, starting channel...', weixin_scan_fail: 'Failed to load QR code',
         weixin_qr_tip: 'QR code expires in ~2 minutes',
+        wecom_scan_btn: 'Scan to Create WeCom Bot', wecom_scan_desc: 'Scan with WeCom to create a bot instantly',
+        wecom_scan_success: 'Bot created, starting channel...',
+        wecom_scan_fail: 'Bot creation failed',
+        wecom_mode_scan: 'Scan QR', wecom_mode_manual: 'Manual',
         tasks_title: 'Scheduled Tasks', tasks_desc: 'View and manage scheduled tasks',
         tasks_coming: 'Coming Soon', tasks_coming_desc: 'Scheduled task management will be available here',
         logs_title: 'Logs', logs_desc: 'Real-time log output (run.log)',
@@ -322,6 +330,11 @@ const attachmentPreview = document.getElementById('attachment-preview');
 let pendingAttachments = [];
 let uploadingCount = 0;
 
+// Input history (like terminal arrow-key recall)
+const inputHistory = [];
+let historyIdx = -1;
+let historySavedDraft = '';
+
 function updateSendBtnState() {
     sendBtn.disabled = uploadingCount > 0 || (!chatInput.value.trim() && pendingAttachments.length === 0);
 }
@@ -435,6 +448,131 @@ chatInput.addEventListener('paste', (e) => {
 chatInput.addEventListener('compositionstart', () => { isComposing = true; });
 chatInput.addEventListener('compositionend', () => { setTimeout(() => { isComposing = false; }, 100); });
 
+// ── Slash Command Menu ───────────────────────────────────────
+const SLASH_COMMANDS = [
+    { cmd: '/help',                desc: '显示命令帮助' },
+    { cmd: '/status',              desc: '查看运行状态' },
+    { cmd: '/context',             desc: '查看对话上下文' },
+    { cmd: '/context clear',       desc: '清除对话上下文' },
+    { cmd: '/skill list',          desc: '查看已安装技能' },
+    { cmd: '/skill list --remote', desc: '浏览技能广场' },
+    { cmd: '/skill search ',       desc: '搜索技能' },
+    { cmd: '/skill install ',      desc: '安装技能 (名称或 GitHub URL)' },
+    { cmd: '/skill uninstall ',    desc: '卸载技能' },
+    { cmd: '/skill info ',         desc: '查看技能详情' },
+    { cmd: '/skill enable ',       desc: '启用技能' },
+    { cmd: '/skill disable ',      desc: '禁用技能' },
+    { cmd: '/config',              desc: '查看当前配置' },
+    { cmd: '/logs',                desc: '查看最近日志' },
+    { cmd: '/version',             desc: '查看版本' },
+];
+
+const slashMenu = document.getElementById('slash-menu');
+let slashActiveIdx = 0;
+let slashFiltered = [];
+let slashJustSelected = false;
+let slashLastFilter = '';
+let slashLastMouseX = -1;
+let slashLastMouseY = -1;
+
+function showSlashMenu(filter) {
+    const q = filter.toLowerCase();
+    if (q === slashLastFilter && !slashMenu.classList.contains('hidden')) return;
+    slashLastFilter = q;
+
+    const newFiltered = SLASH_COMMANDS.filter(c => c.cmd.toLowerCase().startsWith(q));
+    if (newFiltered.length === 0) {
+        hideSlashMenu();
+        return;
+    }
+
+    const changed = newFiltered.length !== slashFiltered.length ||
+        newFiltered.some((c, i) => c.cmd !== slashFiltered[i]?.cmd);
+    slashFiltered = newFiltered;
+    if (changed) slashActiveIdx = 0;
+    slashActiveIdx = Math.min(slashActiveIdx, slashFiltered.length - 1);
+
+    slashNavByKeyboard = true;
+    renderSlashItems();
+    slashMenu.classList.remove('hidden');
+}
+
+function hideSlashMenu() {
+    slashMenu.classList.add('hidden');
+    slashMenu.innerHTML = '';
+    slashFiltered = [];
+    slashActiveIdx = -1;
+    slashLastFilter = '';
+    slashNavByKeyboard = false;
+    slashLastMouseX = -1;
+    slashLastMouseY = -1;
+}
+
+function isSlashMenuVisible() {
+    return !slashMenu.classList.contains('hidden') && slashFiltered.length > 0;
+}
+
+function renderSlashItems() {
+    slashMenu.innerHTML =
+        '<div class="slash-menu-header">Commands</div>' +
+        slashFiltered.map((c, i) =>
+            `<div class="slash-menu-item${i === slashActiveIdx ? ' active' : ''}" data-idx="${i}">` +
+            `<span class="cmd">${escapeHtml(c.cmd)}</span>` +
+            `<span class="desc">${escapeHtml(c.desc)}</span></div>`
+        ).join('');
+
+    const activeEl = slashMenu.querySelector('.slash-menu-item.active');
+    if (activeEl) activeEl.scrollIntoView({ block: 'nearest' });
+}
+
+// Delegated events on the persistent slashMenu container (not destroyed by innerHTML)
+// Use coordinate comparison to distinguish real mouse movement from DOM-rebuild phantom events.
+slashMenu.addEventListener('mousemove', (e) => {
+    if (e.clientX === slashLastMouseX && e.clientY === slashLastMouseY) return;
+    slashLastMouseX = e.clientX;
+    slashLastMouseY = e.clientY;
+    if (!slashNavByKeyboard) return;
+    slashNavByKeyboard = false;
+    const item = e.target.closest('.slash-menu-item');
+    if (!item) return;
+    const idx = parseInt(item.dataset.idx);
+    if (idx === slashActiveIdx) return;
+    slashActiveIdx = idx;
+    slashMenu.querySelectorAll('.slash-menu-item').forEach(el => {
+        el.classList.toggle('active', parseInt(el.dataset.idx) === idx);
+    });
+});
+
+slashMenu.addEventListener('mouseover', (e) => {
+    if (slashNavByKeyboard) return;
+    const item = e.target.closest('.slash-menu-item');
+    if (!item) return;
+    const idx = parseInt(item.dataset.idx);
+    if (idx === slashActiveIdx) return;
+    slashActiveIdx = idx;
+    slashMenu.querySelectorAll('.slash-menu-item').forEach(el => {
+        el.classList.toggle('active', parseInt(el.dataset.idx) === idx);
+    });
+});
+
+slashMenu.addEventListener('mousedown', (e) => {
+    const item = e.target.closest('.slash-menu-item');
+    if (!item) return;
+    e.preventDefault();
+    selectSlashCommand(parseInt(item.dataset.idx));
+});
+
+function selectSlashCommand(idx) {
+    if (idx < 0 || idx >= slashFiltered.length) return;
+    const chosen = slashFiltered[idx].cmd;
+    slashJustSelected = true;
+    chatInput.value = chosen;
+    chatInput.dispatchEvent(new Event('input'));
+    hideSlashMenu();
+    chatInput.focus();
+    chatInput.selectionStart = chatInput.selectionEnd = chosen.length;
+}
+
 chatInput.addEventListener('input', function() {
     this.style.height = '42px';
     const scrollH = this.scrollHeight;
@@ -442,11 +580,92 @@ chatInput.addEventListener('input', function() {
     this.style.height = newH + 'px';
     this.style.overflowY = scrollH > 180 ? 'auto' : 'hidden';
     updateSendBtnState();
+
+    const val = this.value;
+    if (slashJustSelected) {
+        slashJustSelected = false;
+    } else if (val.startsWith('/')) {
+        showSlashMenu(val);
+    } else {
+        hideSlashMenu();
+    }
 });
 
 chatInput.addEventListener('keydown', function(e) {
-    // keyCode 229 indicates an IME is processing the keystroke (reliable across browsers)
     if (e.keyCode === 229 || e.isComposing || isComposing) return;
+
+    if (isSlashMenuVisible()) {
+        if (e.key === 'ArrowDown') {
+            e.preventDefault();
+            slashNavByKeyboard = true;
+            slashActiveIdx = Math.min(slashActiveIdx + 1, slashFiltered.length - 1);
+            renderSlashItems();
+            return;
+        }
+        if (e.key === 'ArrowUp') {
+            e.preventDefault();
+            slashNavByKeyboard = true;
+            slashActiveIdx = Math.max(slashActiveIdx - 1, 0);
+            renderSlashItems();
+            return;
+        }
+        if (e.key === 'Enter' && !e.shiftKey && !e.ctrlKey) {
+            e.preventDefault();
+            selectSlashCommand(slashActiveIdx);
+            return;
+        }
+        if (e.key === 'Escape') {
+            e.preventDefault();
+            hideSlashMenu();
+            return;
+        }
+        if (e.key === 'Tab') {
+            e.preventDefault();
+            selectSlashCommand(slashActiveIdx);
+            return;
+        }
+    }
+
+    // Arrow-key history recall (only when input is empty or already browsing history)
+    if (e.key === 'ArrowUp' && inputHistory.length > 0 && !isSlashMenuVisible()) {
+        const curVal = this.value.trim();
+        const isSingleLine = !this.value.includes('\n');
+        if (isSingleLine && (curVal === '' || historyIdx >= 0)) {
+            e.preventDefault();
+            if (historyIdx < 0) {
+                historySavedDraft = this.value;
+                historyIdx = inputHistory.length - 1;
+            } else if (historyIdx > 0) {
+                historyIdx--;
+            }
+            this.value = inputHistory[historyIdx];
+            slashJustSelected = true;
+            this.dispatchEvent(new Event('input'));
+            hideSlashMenu();
+            this.selectionStart = this.selectionEnd = this.value.length;
+            return;
+        }
+    }
+    if (e.key === 'ArrowDown' && historyIdx >= 0 && !isSlashMenuVisible()) {
+        const isSingleLine = !this.value.includes('\n');
+        if (isSingleLine) {
+            e.preventDefault();
+            if (historyIdx < inputHistory.length - 1) {
+                historyIdx++;
+                this.value = inputHistory[historyIdx];
+            } else {
+                historyIdx = -1;
+                this.value = historySavedDraft;
+                historySavedDraft = '';
+            }
+            slashJustSelected = true;
+            this.dispatchEvent(new Event('input'));
+            hideSlashMenu();
+            this.selectionStart = this.selectionEnd = this.value.length;
+            return;
+        }
+    }
+
     if ((e.ctrlKey || e.shiftKey) && e.key === 'Enter') {
         const start = this.selectionStart;
         const end = this.selectionEnd;
@@ -460,6 +679,10 @@ chatInput.addEventListener('keydown', function(e) {
     }
 });
 
+chatInput.addEventListener('blur', () => {
+    setTimeout(hideSlashMenu, 150);
+});
+
 document.querySelectorAll('.example-card').forEach(card => {
     card.addEventListener('click', () => {
         const textEl = card.querySelector('[data-i18n*="text"]');
@@ -475,6 +698,12 @@ function sendMessage() {
     const text = chatInput.value.trim();
     if (!text && pendingAttachments.length === 0) return;
 
+    if (text) {
+        inputHistory.push(text);
+        historyIdx = -1;
+        historySavedDraft = '';
+    }
+
     const ws = document.getElementById('welcome-screen');
     if (ws) ws.remove();
 
@@ -532,6 +761,7 @@ function startSSE(requestId, loadingEl, timestamp) {
     let botEl = null;
     let stepsEl = null;    // .agent-steps  (thinking summaries + tool indicators)
     let contentEl = null;  // .answer-content (final streaming answer)
+    let mediaEl = null;    // .media-content (images & file attachments)
     let accumulatedText = '';
     let currentToolEl = null;
 
@@ -547,6 +777,7 @@ function startSSE(requestId, loadingEl, timestamp) {
                 <div class="bg-white dark:bg-[#1A1A1A] border border-slate-200 dark:border-white/10 rounded-2xl px-4 py-3 text-sm leading-relaxed msg-content text-slate-700 dark:text-slate-200">
                     <div class="agent-steps"></div>
                     <div class="answer-content sse-streaming"></div>
+                    <div class="media-content"></div>
                 </div>
                 <div class="text-xs text-slate-400 dark:text-slate-500 mt-1.5">${formatTime(timestamp)}</div>
             </div>
@@ -554,6 +785,7 @@ function startSSE(requestId, loadingEl, timestamp) {
         messagesDiv.appendChild(botEl);
         stepsEl = botEl.querySelector('.agent-steps');
         contentEl = botEl.querySelector('.answer-content');
+        mediaEl = botEl.querySelector('.media-content');
     }
 
     es.onmessage = function(e) {
@@ -644,6 +876,38 @@ function startSSE(requestId, loadingEl, timestamp) {
                 currentToolEl = null;
             }
 
+        } else if (item.type === 'image') {
+            ensureBotEl();
+            const imgEl = document.createElement('img');
+            imgEl.src = item.content;
+            imgEl.alt = 'screenshot';
+            imgEl.style.cssText = 'max-width:360px;border-radius:8px;margin:8px 0;cursor:pointer;box-shadow:0 1px 4px rgba(0,0,0,0.1);';
+            imgEl.onclick = () => window.open(item.content, '_blank');
+            mediaEl.appendChild(imgEl);
+            scrollChatToBottom();
+
+        } else if (item.type === 'file') {
+            ensureBotEl();
+            const fileName = item.file_name || item.content.split('/').pop();
+            const fileEl = document.createElement('a');
+            fileEl.href = item.content;
+            fileEl.download = fileName;
+            fileEl.target = '_blank';
+            fileEl.className = 'file-attachment';
+            fileEl.style.cssText = 'display:inline-flex;align-items:center;gap:6px;padding:8px 14px;margin:8px 0;border-radius:8px;background:var(--bg-secondary,#f3f4f6);color:var(--text-primary,#374151);text-decoration:none;font-size:14px;border:1px solid var(--border-color,#e5e7eb);';
+            fileEl.innerHTML = `<i class="fas fa-file-download" style="color:#6b7280;"></i> ${fileName}`;
+            mediaEl.appendChild(fileEl);
+            scrollChatToBottom();
+
+        } else if (item.type === 'phase') {
+            // Coarse progress (e.g. cow install-browser); must not close SSE (unlike "done")
+            ensureBotEl();
+            const wrap = document.createElement('div');
+            wrap.className = 'text-xs sm:text-sm text-slate-600 dark:text-slate-400 border-l-2 border-primary-400 pl-2 py-1 my-0.5';
+            wrap.textContent = String(item.content || '');
+            stepsEl.appendChild(wrap);
+            scrollChatToBottom();
+
         } else if (item.type === 'done') {
             es.close();
             delete activeStreams[requestId];
@@ -732,7 +996,7 @@ function createUserMessageEl(content, timestamp, attachments) {
     const textHtml = content ? renderMarkdown(content) : '';
     el.innerHTML = `
         <div class="max-w-[75%] sm:max-w-[60%]">
-            <div class="bg-primary-400 text-white rounded-2xl px-4 py-2.5 text-sm leading-relaxed msg-content">
+            <div class="bg-primary-400 text-white rounded-2xl px-4 py-2.5 text-sm leading-relaxed msg-content user-bubble">
                 ${attachHtml}${textHtml}
             </div>
             <div class="text-xs text-slate-400 dark:text-slate-500 mt-1.5 text-right">${formatTime(timestamp)}</div>
@@ -1428,7 +1692,7 @@ function renderSkillCard(card, sk) {
         </div>
         <div class="flex-1 min-w-0">
             <div class="flex items-center gap-2 mb-1">
-                <span class="font-medium text-sm text-slate-700 dark:text-slate-200 truncate flex-1">${escapeHtml(sk.name)}</span>
+                <span class="font-medium text-sm text-slate-700 dark:text-slate-200 truncate flex-1">${escapeHtml(sk.display_name || sk.name)}</span>
                 <button
                     role="switch"
                     aria-checked="${enabled}"
@@ -1623,19 +1887,23 @@ function renderActiveChannels() {
         const hasFields = (ch.fields || []).length > 0;
 
         const weixinWaiting = ch.name === 'weixin' && ch.login_status && ch.login_status !== 'logged_in';
+        const wecomNeedsCreds = ch.name === 'wecom_bot' && !_wecomBotHasCreds(ch);
         let statusDot, statusText;
         if (weixinWaiting) {
             statusDot = 'bg-amber-400 animate-pulse';
             statusText = ch.login_status === 'scanned'
                 ? `<span class="text-xs text-primary-500">${t('weixin_scan_scanned')}</span>`
                 : `<span class="text-xs text-amber-500">${t('weixin_scan_waiting')}</span>`;
+        } else if (wecomNeedsCreds) {
+            statusDot = 'bg-amber-400 animate-pulse';
+            statusText = `<span class="text-xs text-amber-500">${t('channels_connecting')}</span>`;
         } else {
             statusDot = 'bg-primary-400';
             statusText = `<span class="text-xs text-primary-500">${t('channels_connected')}</span>`;
         }
 
         card.innerHTML = `
-            <div class="flex items-center gap-4${hasFields || weixinWaiting ? ' mb-5' : ''}">
+            <div class="flex items-center gap-4${hasFields || weixinWaiting || wecomNeedsCreds ? ' mb-5' : ''}">
                 <div class="w-10 h-10 rounded-xl bg-${ch.color}-50 dark:bg-${ch.color}-900/20 flex items-center justify-center flex-shrink-0">
                     <i class="fas ${ch.icon} text-${ch.color}-500 text-base"></i>
                 </div>
@@ -1662,6 +1930,15 @@ function renderActiveChannels() {
                     ${t('weixin_scan_title')}
                 </button>
             </div>` : ''}
+            ${wecomNeedsCreds ? `<div id="wecom-active-auth" class="flex flex-col items-center py-2">
+                <p class="text-sm text-slate-500 dark:text-slate-400 mb-3">${t('wecom_scan_desc')}</p>
+                <button onclick="startWecomBotAuthInCard()"
+                    class="px-5 py-2 rounded-lg bg-emerald-500 hover:bg-emerald-600 text-white text-sm font-medium
+                           cursor-pointer transition-colors duration-150">
+                    <i class="fas fa-qrcode mr-2"></i>${t('wecom_scan_btn')}
+                </button>
+                <div id="wecom-card-scan-status" class="mt-3"></div>
+            </div>` : ''}
             ${hasFields ? `<div class="space-y-4">
                 ${fieldsHtml}
                 <div class="flex items-center justify-end gap-3 pt-1">
@@ -1898,6 +2175,13 @@ function onAddChannelSelect(chName) {
         return;
     }
 
+    if (chName === 'wecom_bot') {
+        actions.classList.add('hidden');
+        const ch = channelsData.find(c => c.name === chName);
+        fieldsContainer.innerHTML = buildWecomBotPanel(ch);
+        return;
+    }
+
     const ch = channelsData.find(c => c.name === chName);
     if (!ch) return;
 
@@ -2119,6 +2403,191 @@ function connectWeixinAfterQr() {
     .catch(() => {});
 }
 
+// =====================================================================
+// WeCom Bot QR Auth
+// =====================================================================
+const WECOM_BOT_SDK_URL = 'https://wwcdn.weixin.qq.com/node/wework/js/wecom-aibot-sdk@0.1.0.min.js';
+const WECOM_BOT_SOURCE = 'cowagent';
+let _wecomSdkLoaded = false;
+
+function ensureWecomSdkLoaded() {
+    return new Promise((resolve, reject) => {
+        if (_wecomSdkLoaded && window.WecomAIBotSDK) { resolve(); return; }
+        if (document.querySelector(`script[src="${WECOM_BOT_SDK_URL}"]`)) {
+            _wecomSdkLoaded = true; resolve(); return;
+        }
+        const s = document.createElement('script');
+        s.src = WECOM_BOT_SDK_URL;
+        s.onload = () => { _wecomSdkLoaded = true; resolve(); };
+        s.onerror = () => reject(new Error('Failed to load WecomAIBotSDK'));
+        document.head.appendChild(s);
+    });
+}
+
+function _wecomBotHasCreds(ch) {
+    if (!ch || !ch.fields) return false;
+    const idField = ch.fields.find(f => f.key === 'wecom_bot_id');
+    const secretField = ch.fields.find(f => f.key === 'wecom_bot_secret');
+    return !!(idField && idField.value && secretField && secretField.value);
+}
+
+function buildWecomBotPanel(ch) {
+    const scanLabel = t('wecom_mode_scan');
+    const manualLabel = t('wecom_mode_manual');
+    const hasCreds = _wecomBotHasCreds(ch);
+    const defaultMode = hasCreds ? 'manual' : 'scan';
+    return `
+        <div id="wecom-bot-panel" data-default-mode="${defaultMode}">
+            <div class="flex items-center justify-center gap-1 mb-5 bg-slate-100 dark:bg-white/5 rounded-lg p-1">
+                <button id="wecom-tab-scan" onclick="switchWecomBotMode('scan')"
+                    class="flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors
+                           bg-white dark:bg-slate-700 text-slate-800 dark:text-slate-100 shadow-sm">
+                    ${scanLabel}
+                </button>
+                <button id="wecom-tab-manual" onclick="switchWecomBotMode('manual')"
+                    class="flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors
+                           text-slate-500 dark:text-slate-400 hover:text-slate-700 dark:hover:text-slate-200">
+                    ${manualLabel}
+                </button>
+            </div>
+            <div id="wecom-mode-content"></div>
+        </div>`;
+}
+
+function switchWecomBotMode(mode) {
+    const scanTab = document.getElementById('wecom-tab-scan');
+    const manualTab = document.getElementById('wecom-tab-manual');
+    const content = document.getElementById('wecom-mode-content');
+    const actions = document.getElementById('add-channel-actions');
+    if (!scanTab || !manualTab || !content) return;
+
+    const activeClasses = 'bg-white dark:bg-slate-700 text-slate-800 dark:text-slate-100 shadow-sm';
+    const inactiveClasses = 'text-slate-500 dark:text-slate-400 hover:text-slate-700 dark:hover:text-slate-200';
+
+    if (mode === 'scan') {
+        scanTab.className = scanTab.className.replace(/text-slate-500[^\s]*/g, '').replace(/hover:\S+/g, '');
+        scanTab.className = `flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${activeClasses}`;
+        manualTab.className = `flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${inactiveClasses}`;
+        actions.classList.add('hidden');
+        content.innerHTML = `
+            <div class="flex flex-col items-center py-4">
+                <p class="text-sm text-slate-600 dark:text-slate-300 mb-2">${t('wecom_scan_desc')}</p>
+                <button onclick="startWecomBotAuth()"
+                    class="mt-3 px-6 py-2.5 rounded-lg bg-emerald-500 hover:bg-emerald-600 text-white text-sm font-medium
+                           cursor-pointer transition-colors duration-150">
+                    <i class="fas fa-qrcode mr-2"></i>${t('wecom_scan_btn')}
+                </button>
+                <div id="wecom-scan-status" class="mt-3"></div>
+            </div>`;
+    } else {
+        manualTab.className = `flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${activeClasses}`;
+        scanTab.className = `flex-1 px-3 py-1.5 rounded-md text-xs font-medium transition-colors ${inactiveClasses}`;
+        const ch = channelsData.find(c => c.name === 'wecom_bot');
+        content.innerHTML = `<div class="space-y-4">${buildChannelFieldsHtml('wecom_bot', ch ? ch.fields || [] : [])}</div>`;
+        bindSecretFieldEvents(content);
+        actions.classList.remove('hidden');
+    }
+}
+
+function startWecomBotAuth() {
+    const statusEl = document.getElementById('wecom-scan-status');
+    ensureWecomSdkLoaded().then(() => {
+        WecomAIBotSDK.openBotInfoAuthWindow({
+            source: WECOM_BOT_SOURCE,
+            onCreated: function(bot) {
+                if (statusEl) {
+                    statusEl.innerHTML = `
+                        <div class="flex flex-col items-center py-2">
+                            <div class="w-10 h-10 rounded-full bg-emerald-50 dark:bg-emerald-900/30 flex items-center justify-center mb-2">
+                                <i class="fas fa-check text-emerald-500 text-lg"></i>
+                            </div>
+                            <p class="text-sm font-medium text-emerald-600 dark:text-emerald-400">${t('wecom_scan_success')}</p>
+                        </div>`;
+                }
+                connectWecomBotAfterAuth(bot.botid, bot.secret);
+            },
+            onError: function(err) {
+                if (statusEl) {
+                    statusEl.innerHTML = `<p class="text-sm text-red-500">${t('wecom_scan_fail')}: ${err.message || err.code || ''}</p>`;
+                }
+            }
+        });
+    }).catch(err => {
+        if (statusEl) {
+            statusEl.innerHTML = `<p class="text-sm text-red-500">SDK load failed: ${err.message}</p>`;
+        }
+    });
+}
+
+function connectWecomBotAfterAuth(botId, secret) {
+    fetch('/api/channels', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'connect',
+            channel: 'wecom_bot',
+            config: { wecom_bot_id: botId, wecom_bot_secret: secret }
+        })
+    })
+    .then(r => r.json())
+    .then(data => {
+        if (data.status === 'success') {
+            const ch = channelsData.find(c => c.name === 'wecom_bot');
+            if (ch) {
+                ch.active = true;
+                (ch.fields || []).forEach(f => {
+                    if (f.key === 'wecom_bot_id') f.value = botId;
+                    if (f.key === 'wecom_bot_secret') f.value = ChannelsHandler_maskSecret(secret);
+                });
+            }
+            setTimeout(() => renderActiveChannels(), 1500);
+        }
+    })
+    .catch(() => {});
+}
+
+function startWecomBotAuthInCard() {
+    const statusEl = document.getElementById('wecom-card-scan-status');
+    ensureWecomSdkLoaded().then(() => {
+        WecomAIBotSDK.openBotInfoAuthWindow({
+            source: WECOM_BOT_SOURCE,
+            onCreated: function(bot) {
+                if (statusEl) {
+                    statusEl.innerHTML = `
+                        <div class="flex flex-col items-center py-2">
+                            <div class="w-10 h-10 rounded-full bg-emerald-50 dark:bg-emerald-900/30 flex items-center justify-center mb-2">
+                                <i class="fas fa-check text-emerald-500 text-lg"></i>
+                            </div>
+                            <p class="text-sm font-medium text-emerald-600 dark:text-emerald-400">${t('wecom_scan_success')}</p>
+                        </div>`;
+                }
+                connectWecomBotAfterAuth(bot.botid, bot.secret);
+            },
+            onError: function(err) {
+                if (statusEl) {
+                    statusEl.innerHTML = `<p class="text-sm text-red-500">${t('wecom_scan_fail')}: ${err.message || err.code || ''}</p>`;
+                }
+            }
+        });
+    }).catch(err => {
+        if (statusEl) {
+            statusEl.innerHTML = `<p class="text-sm text-red-500">SDK load failed: ${err.message}</p>`;
+        }
+    });
+}
+
+// Initialize wecom bot panel with correct default mode when inserted into DOM
+document.addEventListener('DOMContentLoaded', function() {
+    const observer = new MutationObserver(function() {
+        const panel = document.getElementById('wecom-bot-panel');
+        if (panel && !panel.dataset.initialized) {
+            panel.dataset.initialized = '1';
+            switchWecomBotMode(panel.dataset.defaultMode || 'scan');
+        }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+});
+
 // =====================================================================
 // Scheduler View
 // =====================================================================
@@ -2236,7 +2705,12 @@ navigateTo = function(viewId) {
 // =====================================================================
 applyTheme();
 applyI18n();
-document.getElementById('sidebar-version').textContent = `CowAgent ${APP_VERSION}`;
+fetch('/api/version').then(r => r.json()).then(data => {
+    APP_VERSION = `v${data.version}`;
+    document.getElementById('sidebar-version').textContent = `CowAgent ${APP_VERSION}`;
+}).catch(() => {
+    document.getElementById('sidebar-version').textContent = 'CowAgent';
+});
 chatInput.focus();
 
 // Re-enable color transition AFTER first paint so the theme applied in <head>

channel/web/web_channel.py

@@ -96,9 +96,36 @@ class WebChannel(ChatChannel):
                 logger.error(f"No session_id found for request {request_id}")
                 return
 
-            # SSE mode: push done event to SSE queue
+            # SSE mode: push events to SSE queue
             if request_id in self.sse_queues:
                 content = reply.content if reply.content is not None else ""
+
+                # Intermediate status lines (e.g. /install-browser phases) must NOT use "done",
+                # or the frontend closes EventSource and drops subsequent events.
+                if getattr(reply, "sse_phase", False):
+                    self.sse_queues[request_id].put({
+                        "type": "phase",
+                        "content": content,
+                        "request_id": request_id,
+                        "timestamp": time.time(),
+                    })
+                    logger.debug(f"SSE phase for request {request_id}")
+                    return
+
+                # Files are already pushed via on_event (file_to_send) during agent execution.
+                # Skip duplicate file pushes here; just let the done event through.
+                if reply.type in (ReplyType.IMAGE_URL, ReplyType.FILE) and content.startswith("file://"):
+                    text_content = getattr(reply, 'text_content', '')
+                    if text_content:
+                        self.sse_queues[request_id].put({
+                            "type": "done",
+                            "content": text_content,
+                            "request_id": request_id,
+                            "timestamp": time.time()
+                        })
+                    logger.debug(f"SSE skipped duplicate file for request {request_id}")
+                    return
+
                 self.sse_queues[request_id].put({
                     "type": "done",
                     "content": content,
@@ -161,6 +188,19 @@ class WebChannel(ChatChannel):
                     "execution_time": round(exec_time, 2)
                 })
 
+            elif event_type == "file_to_send":
+                file_path = data.get("path", "")
+                file_name = data.get("file_name", os.path.basename(file_path))
+                file_type = data.get("file_type", "file")
+                from urllib.parse import quote
+                web_url = f"/api/file?path={quote(file_path)}"
+                is_image = file_type == "image"
+                q.put({
+                    "type": "image" if is_image else "file",
+                    "content": web_url,
+                    "file_name": file_name,
+                })
+
         return on_event
 
     def upload_file(self):
@@ -377,6 +417,7 @@ class WebChannel(ChatChannel):
             '/message', 'MessageHandler',
             '/upload', 'UploadHandler',
             '/uploads/(.*)', 'UploadsHandler',
+            '/api/file', 'FileServeHandler',
             '/poll', 'PollHandler',
             '/stream', 'StreamHandler',
             '/chat', 'ChatHandler',
@@ -390,6 +431,7 @@ class WebChannel(ChatChannel):
             '/api/scheduler', 'SchedulerHandler',
             '/api/history', 'HistoryHandler',
             '/api/logs', 'LogsHandler',
+            '/api/version', 'VersionHandler',
             '/assets/(.*)', 'AssetsHandler',
         )
         app = web.application(urls, globals(), autoreload=False)
@@ -462,6 +504,32 @@ class UploadsHandler:
             raise web.notfound()
 
 
+class FileServeHandler:
+    def GET(self):
+        """Serve a local file by absolute path (for agent send tool)."""
+        try:
+            params = web.input(path="")
+            file_path = params.path
+            if not file_path or not os.path.isabs(file_path):
+                raise web.notfound()
+            file_path = os.path.normpath(file_path)
+            if not os.path.isfile(file_path):
+                raise web.notfound()
+            content_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"
+            file_name = os.path.basename(file_path)
+            from urllib.parse import quote
+            web.header('Content-Type', content_type)
+            web.header('Content-Disposition', f"inline; filename*=UTF-8''{quote(file_name)}")
+            web.header('Cache-Control', 'public, max-age=3600')
+            with open(file_path, 'rb') as f:
+                return f.read()
+        except web.HTTPError:
+            raise
+        except Exception as e:
+            logger.error(f"[WebChannel] Error serving file: {e}")
+            raise web.notfound()
+
+
 class PollHandler:
     def POST(self):
         return WebChannel().poll_response()
@@ -493,8 +561,8 @@ class ChatHandler:
 class ConfigHandler:
 
     _RECOMMENDED_MODELS = [
-        const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING,
-        const.GLM_5, const.GLM_4_7,
+        const.MINIMAX_M2_7, const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING,
+        const.GLM_5_TURBO, const.GLM_5, const.GLM_4_7,
         const.QWEN3_MAX, const.QWEN35_PLUS,
         const.KIMI_K2_5, const.KIMI_K2,
         const.DOUBAO_SEED_2_PRO, const.DOUBAO_SEED_2_CODE,
@@ -510,14 +578,14 @@ class ConfigHandler:
             "api_key_field": "minimax_api_key",
             "api_base_key": None,
             "api_base_default": None,
-            "models": [const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING],
+            "models": [const.MINIMAX_M2_7, const.MINIMAX_M2_5, const.MINIMAX_M2_1, const.MINIMAX_M2_1_LIGHTNING],
         }),
         ("zhipu", {
             "label": "智谱AI",
             "api_key_field": "zhipu_ai_api_key",
             "api_base_key": "zhipu_ai_api_base",
             "api_base_default": "https://open.bigmodel.cn/api/paas/v4",
-            "models": [const.GLM_5, const.GLM_4_7],
+            "models": [const.GLM_5_TURBO, const.GLM_5, const.GLM_4_7],
         }),
         ("dashscope", {
             "label": "通义千问",
@@ -563,10 +631,17 @@ class ConfigHandler:
         }),
         ("deepseek", {
             "label": "DeepSeek",
-            "api_key_field": "open_ai_api_key",
+            "api_key_field": "deepseek_api_key",
+            "api_base_key": "deepseek_api_base",
+            "api_base_default": "https://api.deepseek.com/v1",
+            "models": [const.DEEPSEEK_CHAT, const.DEEPSEEK_REASONER],
+        }),
+        ("modelscope", {
+            "label": "ModelScope",
+            "api_key_field": "modelscope_api_key",
             "api_base_key": None,
             "api_base_default": None,
-            "models": [const.DEEPSEEK_CHAT, const.DEEPSEEK_REASONER],
+            "models": [const.QWEN3_5_27B, const.QWEN3_235B_A22B_INSTRUCT_2507],
         }),
         ("linkai", {
             "label": "LinkAI",
@@ -579,9 +654,9 @@ class ConfigHandler:
 
     EDITABLE_KEYS = {
         "model", "bot_type", "use_linkai",
-        "open_ai_api_base", "claude_api_base", "gemini_api_base",
+        "open_ai_api_base", "deepseek_api_base", "claude_api_base", "gemini_api_base",
         "zhipu_ai_api_base", "moonshot_base_url", "ark_base_url",
-        "open_ai_api_key", "claude_api_key", "gemini_api_key",
+        "open_ai_api_key", "deepseek_api_key", "claude_api_key", "gemini_api_key",
         "zhipu_ai_api_key", "dashscope_api_key", "moonshot_api_key",
         "ark_api_key", "minimax_api_key", "linkai_api_key",
         "agent_max_context_tokens", "agent_max_context_turns", "agent_max_steps",
@@ -1429,3 +1504,10 @@ class AssetsHandler:
         except Exception as e:
             logger.error(f"Error serving static file: {e}", exc_info=True)  # 添加更详细的错误信息
             raise web.notfound()
+
+
+class VersionHandler:
+    def GET(self):
+        web.header('Content-Type', 'application/json; charset=utf-8')
+        from cli import __version__
+        return json.dumps({"version": __version__})

channel/wecom_bot/wecom_bot_channel.py

@@ -330,28 +330,42 @@ class WecomBotChannel(ChatChannel):
 
         All intermediate segments (thinking before tool calls) and the final answer
         are accumulated into a single stream message, separated by '---'.
+        Throttles push to at most once per 100ms to avoid WebSocket congestion.
         """
         stream_id = uuid.uuid4().hex[:16]
         self._stream_states[req_id] = {
             "stream_id": stream_id,
-            "committed": "",  # finalized content from previous segments
-            "current": "",    # current segment being streamed
+            "committed": "",
+            "current": "",
+            "last_push_time": 0,
+            "last_push_len": 0,
         }
 
-        def _push_stream(state: dict):
-            """Push current stream content to wecom."""
-            self._ws_send({
-                "cmd": "aibot_respond_msg",
-                "headers": {"req_id": req_id},
-                "body": {
-                    "msgtype": "stream",
-                    "stream": {
-                        "id": state["stream_id"],
-                        "finish": False,
-                        "content": state["committed"] + state["current"],
+        def _push_stream(state: dict, force: bool = False):
+            """Push current stream content to wecom (throttled unless forced)."""
+            now = time.time()
+            if not force and now - state["last_push_time"] < 0.1:
+                return
+            content = state["committed"] + state["current"]
+            if len(content) == state["last_push_len"]:
+                return
+            state["last_push_time"] = now
+            state["last_push_len"] = len(content)
+            try:
+                self._ws_send({
+                    "cmd": "aibot_respond_msg",
+                    "headers": {"req_id": req_id},
+                    "body": {
+                        "msgtype": "stream",
+                        "stream": {
+                            "id": state["stream_id"],
+                            "finish": False,
+                            "content": content,
+                        },
                     },
-                },
-            })
+                })
+            except Exception as e:
+                logger.warning(f"[WecomBot] Stream push failed: {e}")
 
         def on_event(event: dict):
             event_type = event.get("type")
@@ -378,6 +392,7 @@ class WecomBotChannel(ChatChannel):
                 else:
                     state["committed"] += state["current"]
                     state["current"] = ""
+                _push_stream(state, force=True)
 
         return on_event
 
@@ -452,11 +467,16 @@ class WecomBotChannel(ChatChannel):
         if req_id:
             state = self._stream_states.pop(req_id, None)
             if state:
-                final_content = state["committed"]
+                final_content = state["committed"] if state["committed"] else content
                 stream_id = state["stream_id"]
             else:
                 final_content = content
                 stream_id = uuid.uuid4().hex[:16]
+
+            # Brief pause so the server finishes processing the last intermediate chunk
+            # before receiving the finish packet
+            time.sleep(0.15)
+
             self._ws_send({
                 "cmd": "aibot_respond_msg",
                 "headers": {"req_id": req_id},

channel/weixin/weixin_api.py

@@ -172,10 +172,8 @@ class WeixinApi:
 
     def get_upload_url(self, filekey: str, media_type: int, to_user_id: str,
                        rawsize: int, rawfilemd5: str, filesize: int,
-                       aeskey: str,
-                       thumb_rawsize: int = 0, thumb_rawfilemd5: str = "",
-                       thumb_filesize: int = 0) -> dict:
-        body = {
+                       aeskey: str) -> dict:
+        return self._post("ilink/bot/getuploadurl", {
             "filekey": filekey,
             "media_type": media_type,
             "to_user_id": to_user_id,
@@ -183,14 +181,8 @@ class WeixinApi:
             "rawfilemd5": rawfilemd5,
             "filesize": filesize,
             "aeskey": aeskey,
-        }
-        if thumb_rawsize > 0:
-            body["thumb_rawsize"] = thumb_rawsize
-            body["thumb_rawfilemd5"] = thumb_rawfilemd5
-            body["thumb_filesize"] = thumb_filesize
-        else:
-            body["no_need_thumb"] = True
-        return self._post("ilink/bot/getuploadurl", body)
+            "no_need_thumb": True,
+        })
 
     # ── getConfig / sendTyping ─────────────────────────────────────────
 
@@ -259,10 +251,18 @@ def _md5_bytes(data: bytes) -> str:
     return hashlib.md5(data).hexdigest()
 
 
+def _aes_ecb_padded_size(plaintext_size: int) -> int:
+    """PKCS7 padded size for AES-128-ECB."""
+    return ((plaintext_size + 1 + 15) // 16) * 16
+
+
+UPLOAD_MAX_RETRIES = 3
+
+
 def upload_media_to_cdn(api: WeixinApi, file_path: str, to_user_id: str,
                         media_type: int) -> dict:
     """
-    Upload a local file to the Weixin CDN.
+    Upload a local file to the Weixin CDN (matching official plugin protocol).
 
     Args:
         api: WeixinApi instance
@@ -275,75 +275,79 @@ def upload_media_to_cdn(api: WeixinApi, file_path: str, to_user_id: str,
     """
     aes_key = os.urandom(16)
     aes_key_hex = aes_key.hex()
+    filekey = uuid.uuid4().hex
 
     with open(file_path, "rb") as f:
         raw_data = f.read()
 
     raw_size = len(raw_data)
     raw_md5 = _md5_bytes(raw_data)
+    cipher_size = _aes_ecb_padded_size(raw_size)
+
     encrypted = _aes_ecb_encrypt(raw_data, aes_key)
-    cipher_size = len(encrypted)
-    filekey = uuid.uuid4().hex
 
-    thumb_rawsize = 0
-    thumb_rawfilemd5 = ""
-    thumb_filesize = 0
+    from urllib.parse import quote
 
-    if media_type == 1:  # IMAGE - generate a tiny thumbnail
+    download_param = None
+    last_error = None
+    for attempt in range(1, UPLOAD_MAX_RETRIES + 1):
         try:
-            from PIL import Image
-            import io
-            img = Image.open(file_path)
-            img.thumbnail((100, 100))
-            buf = io.BytesIO()
-            img.save(buf, format="JPEG", quality=60)
-            thumb_raw = buf.getvalue()
-            thumb_rawsize = len(thumb_raw)
-            thumb_rawfilemd5 = _md5_bytes(thumb_raw)
-            thumb_encrypted = _aes_ecb_encrypt(thumb_raw, aes_key)
-            thumb_filesize = len(thumb_encrypted)
-        except Exception as e:
-            logger.warning(f"[Weixin] Thumbnail generation failed, skipping: {e}")
+            if attempt > 1:
+                filekey = uuid.uuid4().hex
+            resp = api.get_upload_url(
+                filekey=filekey,
+                media_type=media_type,
+                to_user_id=to_user_id,
+                rawsize=raw_size,
+                rawfilemd5=raw_md5,
+                filesize=cipher_size,
+                aeskey=aes_key_hex,
+            )
 
-    resp = api.get_upload_url(
-        filekey=filekey,
-        media_type=media_type,
-        to_user_id=to_user_id,
-        rawsize=raw_size,
-        rawfilemd5=raw_md5,
-        filesize=cipher_size,
-        aeskey=aes_key_hex,
-        thumb_rawsize=thumb_rawsize,
-        thumb_rawfilemd5=thumb_rawfilemd5,
-        thumb_filesize=thumb_filesize,
-    )
+            # API may return either upload_full_url (new) or upload_param (legacy)
+            upload_full_url = resp.get("upload_full_url", "")
+            upload_param = resp.get("upload_param", "")
+            if upload_full_url:
+                cdn_url = upload_full_url
+            elif upload_param:
+                cdn_url = (f"{api.cdn_base_url}/upload"
+                           f"?encrypted_query_param={quote(upload_param)}"
+                           f"&filekey={quote(filekey)}")
+            else:
+                raise RuntimeError(f"[Weixin] getUploadUrl returned neither upload_full_url nor upload_param: {resp}")
 
-    upload_param = resp.get("upload_param", "")
-    if not upload_param:
-        raise RuntimeError(f"[Weixin] getUploadUrl returned no upload_param: {resp}")
-
-    cdn_url = api.cdn_base_url + "?" + upload_param
-    put_resp = requests.put(cdn_url, data=encrypted, headers={
-        "Content-Type": "application/octet-stream",
-        "Content-Length": str(cipher_size),
-    }, timeout=60)
-    put_resp.raise_for_status()
-
-    # Upload thumbnail if we have one
-    thumb_upload_param = resp.get("thumb_upload_param", "")
-    if thumb_upload_param and thumb_filesize > 0:
-        thumb_cdn_url = api.cdn_base_url + "?" + thumb_upload_param
-        try:
-            requests.put(thumb_cdn_url, data=thumb_encrypted, headers={
+            cdn_resp = requests.post(cdn_url, data=encrypted, headers={
                 "Content-Type": "application/octet-stream",
-                "Content-Length": str(thumb_filesize),
-            }, timeout=30)
+                "Content-Length": str(len(encrypted)),
+            }, timeout=120)
+            if 400 <= cdn_resp.status_code < 500:
+                err_msg = cdn_resp.headers.get("x-error-message", cdn_resp.text[:200])
+                raise RuntimeError(f"CDN client error {cdn_resp.status_code}: {err_msg}")
+            cdn_resp.raise_for_status()
+            download_param = cdn_resp.headers.get("x-encrypted-param", "")
+            if not download_param:
+                raise RuntimeError("CDN response missing x-encrypted-param header")
+            logger.debug(f"[Weixin] CDN upload success attempt={attempt} filekey={filekey}")
+            break
         except Exception as e:
-            logger.warning(f"[Weixin] Thumbnail upload failed (non-fatal): {e}")
+            last_error = e
+            if "client error" in str(e):
+                raise
+            if attempt < UPLOAD_MAX_RETRIES:
+                backoff = 2 ** attempt
+                logger.warning(f"[Weixin] CDN upload attempt {attempt} failed, retrying in {backoff}s: {e}")
+                time.sleep(backoff)
+            else:
+                logger.error(f"[Weixin] CDN upload failed after {UPLOAD_MAX_RETRIES} attempts: {e}")
+
+    if not download_param:
+        raise last_error or RuntimeError("CDN upload failed")
+
+    aes_key_b64 = base64.b64encode(aes_key_hex.encode("utf-8")).decode("utf-8")
 
     return {
-        "encrypt_query_param": upload_param,
-        "aes_key_b64": base64.b64encode(aes_key).decode("utf-8"),
+        "encrypt_query_param": download_param,
+        "aes_key_b64": aes_key_b64,
         "ciphertext_size": cipher_size,
         "raw_size": raw_size,
     }
@@ -363,19 +367,30 @@ def download_media_from_cdn(cdn_base_url: str, encrypt_query_param: str,
     Returns:
         save_path on success
     """
-    url = cdn_base_url + "?" + encrypt_query_param
+    from urllib.parse import quote
+    url = f"{cdn_base_url}/download?encrypted_query_param={quote(encrypt_query_param)}"
     resp = requests.get(url, timeout=60)
     resp.raise_for_status()
 
-    # Determine key format (hex string or base64)
+    # Determine key format:
+    # 1) 32-char hex string → 16 raw bytes
+    # 2) base64 string → decode → if 32 bytes, treat as hex-encoded → 16 raw bytes
+    # 3) base64 string → decode → 16 raw bytes directly
     try:
         key_bytes = bytes.fromhex(aes_key)
         if len(key_bytes) != 16:
             raise ValueError()
     except (ValueError, TypeError):
-        key_bytes = base64.b64decode(aes_key)
-        if len(key_bytes) != 16:
-            raise ValueError(f"Invalid AES key length: {len(key_bytes)}")
+        decoded = base64.b64decode(aes_key)
+        if len(decoded) == 32:
+            try:
+                key_bytes = bytes.fromhex(decoded.decode("ascii"))
+            except (ValueError, UnicodeDecodeError):
+                raise ValueError(f"Invalid AES key: 32 bytes but not valid hex")
+        elif len(decoded) == 16:
+            key_bytes = decoded
+        else:
+            raise ValueError(f"Invalid AES key length after base64 decode: {len(decoded)}")
 
     decrypted = _aes_ecb_decrypt(resp.content, key_bytes)
 

channel/weixin/weixin_channel.py

@@ -31,6 +31,8 @@ BACKOFF_DELAY = 30
 RETRY_DELAY = 2
 SESSION_EXPIRED_ERRCODE = -14
 TEXT_CHUNK_LIMIT = 4000
+QR_LOGIN_TIMEOUT_S = 480
+QR_MAX_REFRESHES = 10
 
 
 def _load_credentials(cred_path: str) -> dict:
@@ -80,6 +82,8 @@ class WeixinChannel(ChatChannel):
     # ── Lifecycle ──────────────────────────────────────────────────────
 
     def startup(self):
+        self._stop_event.clear()
+
         base_url = conf().get("weixin_base_url", DEFAULT_BASE_URL)
         cdn_base_url = conf().get("weixin_cdn_base_url", CDN_BASE_URL)
         token = conf().get("weixin_token", "")
@@ -95,17 +99,9 @@ class WeixinChannel(ChatChannel):
                 base_url = creds["base_url"]
 
         if not token:
-            logger.info("[Weixin] No token found, starting QR login...")
-            self.login_status = self.LOGIN_STATUS_WAITING
-            login_result = self._qr_login(base_url)
-            if not login_result:
-                self.login_status = self.LOGIN_STATUS_IDLE
-                err = "[Weixin] QR login failed. Set weixin_token in config or run login again."
-                logger.error(err)
-                self.report_startup_error(err)
+            token, base_url = self._login_with_retry(base_url)
+            if not token:
                 return
-            token = login_result["token"]
-            base_url = login_result.get("base_url", base_url)
 
         self.api = WeixinApi(base_url=base_url, token=token, cdn_base_url=cdn_base_url)
         self.login_status = self.LOGIN_STATUS_OK
@@ -114,9 +110,26 @@ class WeixinChannel(ChatChannel):
                      f"如需重新扫码登录请删除该文件后重启")
         self.report_startup_success()
 
-        self._stop_event.clear()
         self._poll_loop()
 
+    def _login_with_retry(self, base_url: str) -> tuple:
+        """Attempt QR login, then wait for stop if failed.
+        Returns (token, base_url) on success, or ("", "") if stopped."""
+        logger.info("[Weixin] No token found, starting QR login...")
+        self.login_status = self.LOGIN_STATUS_WAITING
+        login_result = self._qr_login(base_url)
+        if login_result:
+            return login_result["token"], login_result.get("base_url", base_url)
+
+        self.login_status = self.LOGIN_STATUS_IDLE
+        if not self._stop_event.is_set():
+            logger.info("[Weixin] QR login timed out, waiting for stop or reconnect...")
+            print("  二维码登录超时，请通过控制台重新接入\n")
+            self._stop_event.wait()
+
+        logger.info("[Weixin] Login cancelled by stop event")
+        return "", ""
+
     def stop(self):
         logger.info("[Weixin] stop() called")
         self._stop_event.set()
@@ -202,14 +215,21 @@ class WeixinChannel(ChatChannel):
             return {}
 
         self._current_qr_url = qrcode_url
-        logger.info(f"[Weixin] QR code URL: {qrcode_url}")
+        logger.info(f"[Weixin] 微信二维码链接: {qrcode_url}")
         self._print_qr(qrcode_url)
         self._notify_cloud_qrcode(qrcode_url)
         print("  等待扫码...\n")
 
         scanned_printed = False
+        refresh_count = 0
+        deadline = time.time() + QR_LOGIN_TIMEOUT_S
 
         while not self._stop_event.is_set():
+            if time.time() >= deadline:
+                logger.warning(f"[Weixin] QR login timed out after {QR_LOGIN_TIMEOUT_S}s")
+                print(f"\n  二维码登录超时（{QR_LOGIN_TIMEOUT_S}s），请重启后重试")
+                break
+
             try:
                 status_resp = api.poll_qr_status(qrcode)
             except Exception as e:
@@ -226,14 +246,19 @@ class WeixinChannel(ChatChannel):
                     print("  已扫码，请在手机上确认...")
                     scanned_printed = True
             elif status == "expired":
-                print("  二维码已过期，正在刷新...")
+                refresh_count += 1
+                if refresh_count >= QR_MAX_REFRESHES:
+                    logger.warning(f"[Weixin] QR code refreshed {QR_MAX_REFRESHES} times, giving up")
+                    print(f"\n  二维码已刷新 {QR_MAX_REFRESHES} 次仍未扫码，请重启后重试")
+                    break
+                print(f"  二维码已过期，正在刷新（{refresh_count}/{QR_MAX_REFRESHES}）...")
                 try:
                     qr_resp = api.fetch_qr_code()
                     qrcode = qr_resp.get("qrcode", "")
                     qrcode_url = qr_resp.get("qrcode_img_content", "")
                     scanned_printed = False
                     self._current_qr_url = qrcode_url
-                    logger.info(f"[Weixin] New QR code: {qrcode_url}")
+                    logger.info(f"[Weixin] 微信二维码链接 ({refresh_count}/{QR_MAX_REFRESHES}): {qrcode_url}")
                     self._print_qr(qrcode_url)
                     self._notify_cloud_qrcode(qrcode_url)
                 except Exception as e:
@@ -267,8 +292,9 @@ class WeixinChannel(ChatChannel):
 
             self._stop_event.wait(1)
 
-        logger.info("[Weixin] QR login cancelled by stop event")
         self._current_qr_url = ""
+        if self._stop_event.is_set():
+            logger.info("[Weixin] QR login cancelled by stop event")
         return {}
 
     # ── Long-poll loop ─────────────────────────────────────────────────

channel/weixin/weixin_message.py

@@ -184,12 +184,16 @@ class WeixinMessage(ChatMessage):
             logger.warning(f"[Weixin] Missing CDN params for media download (type={media_type})")
             return ""
 
-        ext_map = {ITEM_IMAGE: ".jpg", ITEM_VIDEO: ".mp4", ITEM_FILE: "", ITEM_VOICE: ".silk"}
-        ext = ext_map.get(media_type, "")
         if media_type == ITEM_FILE:
-            ext = os.path.splitext(info.get("file_name", ""))[1] or ".bin"
-
-        save_path = os.path.join(_get_tmp_dir(), f"wx_{self.msg_id}{ext}")
+            original_name = info.get("file_name", "")
+            if original_name:
+                save_path = os.path.join(_get_tmp_dir(), original_name)
+            else:
+                save_path = os.path.join(_get_tmp_dir(), f"wx_{self.msg_id}.bin")
+        else:
+            ext_map = {ITEM_IMAGE: ".jpg", ITEM_VIDEO: ".mp4", ITEM_VOICE: ".silk"}
+            ext = ext_map.get(media_type, "")
+            save_path = os.path.join(_get_tmp_dir(), f"wx_{self.msg_id}{ext}")
 
         try:
             download_media_from_cdn(cdn_base_url, encrypt_param, aes_key, save_path)

cli/VERSION

@@ -0,0 +1 @@
+2.0.4

cli/__init__.py

@@ -0,0 +1,13 @@
+"""CowAgent CLI - Manage your CowAgent from the command line."""
+
+import os as _os
+
+def _read_version():
+    version_file = _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "VERSION")
+    try:
+        with open(version_file, "r") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        return "0.0.0"
+
+__version__ = _read_version()

cli/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running as: python -m cli"""
+from cli.cli import main
+
+main()

cli/cli.py

@@ -0,0 +1,76 @@
+"""CowAgent CLI entry point."""
+
+import click
+from cli import __version__
+from cli.commands.skill import skill
+from cli.commands.process import start, stop, restart, update, status, logs
+from cli.commands.context import context
+from cli.commands.install import install_browser
+
+
+HELP_TEXT = """Usage: cow COMMAND [ARGS]...
+
+  CowAgent CLI - Manage your CowAgent instance.
+
+Commands:
+  help     Show this message.
+  version  Show the version.
+  start    Start CowAgent.
+  stop     Stop CowAgent.
+  restart  Restart CowAgent.
+  update   Update CowAgent and restart.
+  status   Show CowAgent running status.
+  logs     View CowAgent logs.
+  skill    Manage CowAgent skills.
+  install-browser  Install browser tool (Playwright + Chromium).
+
+Tip: You can also send /help, /skill list, etc. in agent chat."""
+
+
+class CowCLI(click.Group):
+
+    def format_help(self, ctx, formatter):
+        formatter.write(HELP_TEXT.strip())
+        formatter.write("\n")
+
+    def parse_args(self, ctx, args):
+        if args and args[0] == 'help':
+            click.echo(HELP_TEXT.strip())
+            ctx.exit(0)
+        return super().parse_args(ctx, args)
+
+
+@click.group(cls=CowCLI, invoke_without_command=True, context_settings=dict(help_option_names=[]))
+@click.pass_context
+def main(ctx):
+    """CowAgent CLI - Manage your CowAgent instance."""
+    if ctx.invoked_subcommand is None:
+        click.echo(HELP_TEXT.strip())
+
+
+@main.command()
+def version():
+    """Show the version."""
+    click.echo(f"cow {__version__}")
+
+
+@main.command(name='help')
+@click.pass_context
+def help_cmd(ctx):
+    """Show this message."""
+    click.echo(HELP_TEXT.strip())
+
+
+main.add_command(skill)
+main.add_command(start)
+main.add_command(stop)
+main.add_command(restart)
+main.add_command(update)
+main.add_command(status)
+main.add_command(logs)
+main.add_command(context)
+main.add_command(install_browser)
+
+
+if __name__ == '__main__':
+    main()

cli/commands/context.py

@@ -0,0 +1,29 @@
+"""cow context - Context management commands."""
+
+import click
+
+
+CHAT_HINT = (
+    "Context commands operate on the running agent's memory.\n"
+    "Please send the command in a chat conversation instead:\n\n"
+    "  /context        - View current context info\n"
+    "  /context clear  - Clear conversation context"
+)
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def context(ctx):
+    """View or manage conversation context.
+
+    Context commands need access to the running agent's memory.
+    Use them in chat conversations: /context or /context clear
+    """
+    if ctx.invoked_subcommand is None:
+        click.echo(f"\n  {CHAT_HINT}\n")
+
+
+@context.command()
+def clear():
+    """Clear conversation context (messages history)."""
+    click.echo(f"\n  {CHAT_HINT}\n")

cli/commands/install.py

@@ -0,0 +1,259 @@
+"""cow install-browser - Install Playwright + Chromium for the browser tool."""
+
+import os
+import sys
+import subprocess
+from typing import Callable, Optional
+
+import click
+
+PLAYWRIGHT_VERSION = "1.52.0"
+PLAYWRIGHT_LEGACY_VERSION = "1.28.0"
+GLIBC_THRESHOLD = (2, 28)
+CHINA_MIRROR = "https://registry.npmmirror.com/-/binary/playwright"
+
+# stream(msg, fg=None) — fg is "yellow" | "green" | "red" | None
+StreamFn = Callable[[str, Optional[str]], None]
+# on_phase(msg) — coarse-grained progress for chat channels (Chinese)
+PhaseFn = Callable[[str], None]
+
+
+def _phase(cb: Optional[PhaseFn], msg: str) -> None:
+    if cb:
+        cb(msg)
+
+
+def _has_display() -> bool:
+    """Check if a graphical display is available (Linux only)."""
+    return bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+
+
+def _is_headless_linux() -> bool:
+    return sys.platform == "linux" and not _has_display()
+
+
+def _get_installed_version() -> str:
+    try:
+        out = subprocess.check_output(
+            [sys.executable, "-c", "import playwright; print(playwright.__version__)"],
+            stderr=subprocess.DEVNULL,
+        )
+        return out.decode().strip()
+    except Exception:
+        return ""
+
+
+def _version_tuple(v: str):
+    try:
+        return tuple(int(x) for x in v.split(".")[:3])
+    except (ValueError, AttributeError):
+        return (0, 0, 0)
+
+
+def _get_glibc_version():
+    if sys.platform != "linux":
+        return None
+    try:
+        import ctypes
+        libc = ctypes.CDLL("libc.so.6")
+        gnu_get_libc_version = libc.gnu_get_libc_version
+        gnu_get_libc_version.restype = ctypes.c_char_p
+        ver = gnu_get_libc_version().decode()
+        parts = ver.split(".")
+        return (int(parts[0]), int(parts[1]))
+    except Exception:
+        return None
+
+
+def _is_china_network() -> bool:
+    try:
+        out = subprocess.check_output(
+            [sys.executable, "-m", "pip", "config", "get", "global.index-url"],
+            stderr=subprocess.DEVNULL,
+        )
+        url = out.decode().strip().lower()
+        return any(kw in url for kw in ("tsinghua", "aliyun", "npmmirror", "douban", "ustc", "huawei", "tencentyun"))
+    except Exception:
+        return False
+
+
+def _pip_install(package_spec: str, stream: StreamFn) -> int:
+    """Install a package, retrying with --user on permission failure."""
+    python = sys.executable
+    ret = subprocess.call([python, "-m", "pip", "install", package_spec])
+    if ret != 0:
+        stream("  Retrying with --user flag...", "yellow")
+        ret = subprocess.call([python, "-m", "pip", "install", "--user", package_spec])
+    return ret
+
+
+def _default_stream(msg: str, fg: Optional[str] = None) -> None:
+    """CLI: colored click output."""
+    if fg == "yellow":
+        click.echo(click.style(msg, fg="yellow"))
+    elif fg == "green":
+        click.echo(click.style(msg, fg="green"))
+    elif fg == "red":
+        click.echo(click.style(msg, fg="red"))
+    else:
+        click.echo(msg)
+
+
+def run_install_browser(
+    stream: Optional[StreamFn] = None,
+    on_phase: Optional[PhaseFn] = None,
+) -> int:
+    """
+    Install Playwright Python package, optional Linux deps, and Chromium.
+
+    Reused by ``cow install-browser`` CLI and chat ``/install-browser``.
+
+    Args:
+        stream: Optional callback ``(message, fg)`` for each line. ``fg`` is
+            ``yellow`` / ``green`` / ``red`` or None. Defaults to colored click output.
+        on_phase: Optional callback for coarse progress (e.g. push to chat);
+            messages are short Chinese status lines.
+
+    Returns:
+        0 on success, 1 on fatal failure (pip or chromium install failed).
+    """
+    stream = stream or _default_stream
+    python = sys.executable
+    legacy_mode = False
+
+    _phase(on_phase, "🔧 开始安装浏览器工具依赖（约几分钟，请耐心等待）…")
+
+    glibc = _get_glibc_version()
+    if glibc and glibc < GLIBC_THRESHOLD:
+        legacy_mode = True
+        glibc_str = f"{glibc[0]}.{glibc[1]}"
+        stream(
+            f"glibc {glibc_str} detected (< 2.28). "
+            f"Will install playwright {PLAYWRIGHT_LEGACY_VERSION} for compatibility.",
+            "yellow",
+        )
+        stream("  Note: upgrade your OS for full browser tool support.", "yellow")
+        stream("")
+        _phase(
+            on_phase,
+            f"ℹ️ 检测到 glibc {glibc_str}（较旧），将安装兼容版 Playwright {PLAYWRIGHT_LEGACY_VERSION}。",
+        )
+
+    target_version = PLAYWRIGHT_LEGACY_VERSION if legacy_mode else PLAYWRIGHT_VERSION
+
+    _phase(on_phase, "📦 [1/3] 正在安装 Playwright Python 包…")
+    stream("[1/3] Installing playwright Python package...", "yellow")
+    ret = _pip_install(f"playwright=={target_version}", stream)
+    if ret != 0:
+        stream("Failed to install playwright package.", "red")
+        _phase(on_phase, "❌ [1/3] Playwright Python 包安装失败。")
+        return 1
+
+    installed = _get_installed_version()
+    if installed:
+        stream(f"  playwright {installed} installed.", "green")
+    stream("")
+    _phase(on_phase, f"✅ [1/3] Playwright 包已安装（{installed or target_version}）。")
+
+    if sys.platform == "linux":
+        _phase(on_phase, "🔧 [2/3] 正在安装 Linux 系统依赖与轻量中文字体（文泉驿正黑，部分步骤可能需要 sudo）…")
+        stream("[2/3] Installing system dependencies (Linux)...", "yellow")
+        ret = subprocess.call([python, "-m", "playwright", "install-deps", "chromium"])
+        if ret != 0:
+            stream(
+                "  Could not auto-install system deps (may need sudo).\n"
+                f"  Run manually: sudo {python} -m playwright install-deps chromium",
+                "yellow",
+            )
+        # Prefer fonts-wqy-zenhei only (~few MB). fonts-noto-cjk is much larger (~150MB+).
+        stream("  Installing CJK font (fonts-wqy-zenhei, lightweight)...")
+        font_ret = subprocess.call(
+            ["sudo", "apt-get", "install", "-y", "--no-install-recommends", "fonts-wqy-zenhei"],
+            stderr=subprocess.DEVNULL,
+        )
+        if font_ret != 0:
+            stream(
+                "  Could not auto-install CJK font.\n"
+                "  Run manually: sudo apt-get install -y fonts-wqy-zenhei\n"
+                "  (Optional, larger full coverage: sudo apt-get install -y fonts-noto-cjk)",
+                "yellow",
+            )
+        else:
+            subprocess.call(["fc-cache", "-fv"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            stream("  CJK font (wqy-zenhei) installed.", "green")
+        _phase(
+            on_phase,
+            "✅ [2/3] Linux 依赖与字体步骤已执行（若有权限问题请查看服务器日志或手动执行提示命令）。",
+        )
+    else:
+        stream(f"[2/3] Skipping system deps (not needed on {sys.platform}).", "yellow")
+        _phase(on_phase, f"ℹ️ [2/3] 当前系统（{sys.platform}）跳过 Linux 专用依赖。")
+    stream("")
+
+    _phase(on_phase, "🌐 [3/3] 正在下载并安装 Chromium（体积较大，请耐心等待）…")
+    stream("[3/3] Installing Chromium browser...", "yellow")
+    cmd = [python, "-m", "playwright", "install", "chromium"]
+
+    if _is_headless_linux() and not legacy_mode:
+        ver = _version_tuple(installed or "")
+        if ver >= (1, 57, 0):
+            cmd.append("--only-shell")
+            stream("  (headless shell for Linux server)", None)
+        else:
+            stream("  (full Chromium)", None)
+    elif sys.platform == "linux" and _has_display():
+        stream("  (full browser for Linux desktop)", None)
+
+    env = os.environ.copy()
+    use_mirror = _is_china_network()
+    if use_mirror:
+        env["PLAYWRIGHT_DOWNLOAD_HOST"] = CHINA_MIRROR
+        stream(f"  (using China mirror: {CHINA_MIRROR})", None)
+        _phase(on_phase, "📡 检测到国内 pip 源配置，Chromium 将优先走国内镜像下载。")
+
+    ret = subprocess.call(cmd, env=env)
+
+    if ret != 0 and use_mirror:
+        stream("  Mirror download failed, retrying with official CDN...", "yellow")
+        _phase(on_phase, "⚠️ 镜像下载失败，正在改用官方源重试…")
+        env_no_mirror = os.environ.copy()
+        env_no_mirror.pop("PLAYWRIGHT_DOWNLOAD_HOST", None)
+        ret = subprocess.call(cmd, env=env_no_mirror)
+
+    if ret != 0:
+        stream("Failed to install Chromium.", "red")
+        _phase(on_phase, "❌ [3/3] Chromium 安装失败。")
+        return 1
+
+    stream("")
+    _phase(on_phase, "✅ [3/3] Chromium 已安装。")
+
+    stream("Verifying browser installation...", None)
+    _phase(on_phase, "🔍 正在验证 Playwright 能否正常加载…")
+    ret = subprocess.call(
+        [python, "-c", "from playwright.sync_api import sync_playwright; print('OK')"],
+        stderr=subprocess.DEVNULL,
+    )
+    if ret != 0:
+        stream(
+            "  Warning: playwright import failed. Browser tool may not work on this system.\n"
+            "  Consider upgrading your OS or using Docker.",
+            "yellow",
+        )
+        _phase(on_phase, "⚠️ 验证未完全通过：本机可能仍无法使用浏览器工具，请查看日志或升级系统。")
+    else:
+        stream("  Verification passed.", "green")
+        _phase(on_phase, "✅ 验证通过。")
+
+    stream("")
+    stream("Browser tool ready! Restart CowAgent to enable it.", "green")
+    _phase(on_phase, "🎉 全部步骤结束。请重启 CowAgent 后使用 browser 工具。")
+    return 0
+
+
+@click.command("install-browser")
+def install_browser():
+    """Install browser tool dependencies (Playwright + Chromium)."""
+    code = run_install_browser()
+    if code != 0:
+        raise SystemExit(code)

cli/commands/process.py

@@ -0,0 +1,281 @@
+"""cow start/stop/restart/status/logs - Process management commands."""
+
+import os
+import sys
+import subprocess
+import time
+from typing import Optional
+
+import click
+
+from cli.utils import get_project_root
+
+_IS_WIN = sys.platform == "win32"
+
+
+def _get_pid_file():
+    return os.path.join(get_project_root(), ".cow.pid")
+
+
+def _get_log_file():
+    return os.path.join(get_project_root(), "nohup.out")
+
+
+def _is_pid_alive(pid: int) -> bool:
+    """Check whether a process is still running (cross-platform)."""
+    if _IS_WIN:
+        try:
+            out = subprocess.check_output(
+                ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
+                stderr=subprocess.DEVNULL,
+            )
+            return str(pid) in out.decode(errors="ignore")
+        except Exception:
+            return False
+    else:
+        try:
+            os.kill(pid, 0)
+            return True
+        except (ProcessLookupError, PermissionError):
+            return False
+
+
+def _kill_pid(pid: int, force: bool = False):
+    """Terminate a process by PID (cross-platform)."""
+    if _IS_WIN:
+        flag = "/F" if force else ""
+        cmd = ["taskkill"]
+        if force:
+            cmd.append("/F")
+        cmd.extend(["/PID", str(pid)])
+        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    else:
+        import signal
+        sig = signal.SIGKILL if force else signal.SIGTERM
+        os.kill(pid, sig)
+
+
+def _read_pid() -> Optional[int]:
+    pid_file = _get_pid_file()
+    if not os.path.exists(pid_file):
+        return None
+    try:
+        with open(pid_file, "r") as f:
+            pid = int(f.read().strip())
+        if _is_pid_alive(pid):
+            return pid
+        os.remove(pid_file)
+        return None
+    except (ValueError, OSError):
+        try:
+            os.remove(pid_file)
+        except OSError:
+            pass
+        return None
+
+
+def _write_pid(pid: int):
+    with open(_get_pid_file(), "w") as f:
+        f.write(str(pid))
+
+
+def _remove_pid():
+    pid_file = _get_pid_file()
+    if os.path.exists(pid_file):
+        os.remove(pid_file)
+
+
+@click.command()
+@click.option("--foreground", "-f", is_flag=True, help="Run in foreground (don't daemonize)")
+@click.option("--no-logs", is_flag=True, help="Don't tail logs after starting")
+def start(foreground, no_logs):
+    """Start CowAgent."""
+    pid = _read_pid()
+    if pid:
+        click.echo(f"CowAgent is already running (PID: {pid}).")
+        return
+
+    root = get_project_root()
+    app_py = os.path.join(root, "app.py")
+    if not os.path.exists(app_py):
+        click.echo("Error: app.py not found in project root.", err=True)
+        sys.exit(1)
+
+    python = sys.executable
+
+    if foreground:
+        click.echo("Starting CowAgent in foreground...")
+        if _IS_WIN:
+            sys.exit(subprocess.call([python, app_py], cwd=root))
+        else:
+            os.execv(python, [python, app_py])
+    else:
+        log_file = _get_log_file()
+        click.echo("Starting CowAgent...")
+
+        popen_kwargs = dict(cwd=root)
+        if _IS_WIN:
+            CREATE_NO_WINDOW = 0x08000000
+            popen_kwargs["creationflags"] = (
+                subprocess.CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
+            )
+        else:
+            popen_kwargs["start_new_session"] = True
+
+        with open(log_file, "a") as log:
+            proc = subprocess.Popen(
+                [python, app_py],
+                stdout=log,
+                stderr=log,
+                **popen_kwargs,
+            )
+        _write_pid(proc.pid)
+        click.echo(click.style(f"✓ CowAgent started (PID: {proc.pid})", fg="green"))
+        click.echo(f"  Logs: {log_file}")
+
+        if not no_logs:
+            click.echo("  Press Ctrl+C to stop tailing logs.\n")
+            _tail_log(log_file)
+
+
+@click.command()
+def stop():
+    """Stop CowAgent."""
+    pid = _read_pid()
+    if not pid:
+        click.echo("CowAgent is not running.")
+        return
+
+    click.echo(f"Stopping CowAgent (PID: {pid})...")
+    try:
+        _kill_pid(pid)
+        for _ in range(30):
+            time.sleep(0.1)
+            if not _is_pid_alive(pid):
+                break
+        else:
+            _kill_pid(pid, force=True)
+    except (ProcessLookupError, OSError):
+        pass
+
+    _remove_pid()
+    click.echo(click.style("✓ CowAgent stopped.", fg="green"))
+
+
+@click.command()
+@click.option("--no-logs", is_flag=True, help="Don't tail logs after restarting")
+@click.pass_context
+def restart(ctx, no_logs):
+    """Restart CowAgent."""
+    ctx.invoke(stop)
+    time.sleep(1)
+    ctx.invoke(start, no_logs=no_logs)
+
+
+@click.command()
+@click.pass_context
+def update(ctx):
+    """Update CowAgent and restart."""
+    root = get_project_root()
+
+    # 1. Git pull while service is still running
+    if os.path.isdir(os.path.join(root, ".git")):
+        click.echo("Pulling latest code...")
+        ret = subprocess.call(["git", "pull"], cwd=root)
+        if ret != 0:
+            click.echo("Error: git pull failed.", err=True)
+            sys.exit(1)
+    else:
+        click.echo("Not a git repository, skipping code update.")
+
+    # 2. Stop service
+    ctx.invoke(stop)
+
+    # 3. Install dependencies
+    python = sys.executable
+    req_file = os.path.join(root, "requirements.txt")
+    if os.path.exists(req_file):
+        click.echo("Installing dependencies...")
+        subprocess.call(
+            [python, "-m", "pip", "install", "-r", "requirements.txt", "-q"],
+            cwd=root,
+        )
+    click.echo("Reinstalling cow CLI...")
+    subprocess.call(
+        [python, "-m", "pip", "install", "-e", ".", "-q"],
+        cwd=root,
+    )
+
+    # 4. Start service and follow logs
+    click.echo("")
+    time.sleep(1)
+    ctx.invoke(start, no_logs=False)
+
+
+@click.command()
+def status():
+    """Show CowAgent running status."""
+    from cli import __version__
+    from cli.utils import load_config_json
+
+    pid = _read_pid()
+    if pid:
+        click.echo(click.style(f"● CowAgent is running (PID: {pid})", fg="green"))
+    else:
+        click.echo(click.style("● CowAgent is not running", fg="red"))
+
+    click.echo(f"  版本: v{__version__}")
+
+    cfg = load_config_json()
+    if cfg:
+        channel = cfg.get("channel_type", "unknown")
+        if isinstance(channel, list):
+            channel = ", ".join(channel)
+        click.echo(f"  通道: {channel}")
+        click.echo(f"  模型: {cfg.get('model', 'unknown')}")
+        mode = "Agent" if cfg.get("agent") else "Chat"
+        click.echo(f"  模式: {mode}")
+
+
+@click.command()
+@click.option("--follow", "-f", is_flag=True, help="Follow log output")
+@click.option("--lines", "-n", default=50, help="Number of lines to show")
+def logs(follow, lines):
+    """View CowAgent logs."""
+    log_file = _get_log_file()
+    if not os.path.exists(log_file):
+        click.echo("No log file found.")
+        return
+
+    if follow:
+        _tail_log(log_file, lines)
+    else:
+        _print_last_lines(log_file, lines)
+
+
+def _print_last_lines(file_path: str, n: int = 50):
+    """Print the last N lines of a file (cross-platform)."""
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            all_lines = f.readlines()
+        for line in all_lines[-n:]:
+            click.echo(line, nl=False)
+    except Exception as e:
+        click.echo(f"Error reading log file: {e}", err=True)
+
+
+def _tail_log(log_file: str, lines: int = 50):
+    """Follow log file output. Blocks until Ctrl+C (cross-platform)."""
+    _print_last_lines(log_file, lines)
+
+    try:
+        with open(log_file, "r", encoding="utf-8", errors="replace") as f:
+            f.seek(0, 2)
+            while True:
+                line = f.readline()
+                if line:
+                    click.echo(line, nl=False)
+                else:
+                    time.sleep(0.3)
+    except KeyboardInterrupt:
+        pass

cli/utils.py

@@ -0,0 +1,62 @@
+"""Shared utilities for cow CLI."""
+
+import os
+import sys
+import json
+
+
+def get_project_root() -> str:
+    """Get the CowAgent project root directory."""
+    # cli/ is directly under the project root
+    return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def get_workspace_dir() -> str:
+    """Get the agent workspace directory from config, defaulting to ~/cow."""
+    config = load_config_json()
+    workspace = config.get("agent_workspace", "~/cow")
+    return os.path.expanduser(workspace)
+
+
+def get_skills_dir() -> str:
+    """Get the custom skills directory."""
+    return os.path.join(get_workspace_dir(), "skills")
+
+
+def get_builtin_skills_dir() -> str:
+    """Get the builtin skills directory."""
+    return os.path.join(get_project_root(), "skills")
+
+
+def load_config_json() -> dict:
+    """Load config.json from project root."""
+    config_path = os.path.join(get_project_root(), "config.json")
+    if not os.path.exists(config_path):
+        return {}
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def load_skills_config() -> dict:
+    """Load skills_config.json from the custom skills directory."""
+    path = os.path.join(get_skills_dir(), "skills_config.json")
+    if not os.path.exists(path):
+        return {}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def ensure_sys_path():
+    """Add project root to sys.path so we can import agent modules."""
+    root = get_project_root()
+    if root not in sys.path:
+        sys.path.insert(0, root)
+
+
+SKILL_HUB_API = "https://skills.cowagent.ai/api"

common/cloud_client.py

@@ -222,7 +222,14 @@ class CloudClient(LinkAIClient):
             return
 
         existing_ch = self.channel_mgr.get_channel(channel_type)
-        if existing_ch and not cred_changed:
+        skip_restart = existing_ch and not cred_changed
+        if skip_restart and channel_type in ("weixin", "wx"):
+            login_status = getattr(existing_ch, "login_status", "")
+            if login_status != "logged_in":
+                skip_restart = False
+                logger.info(f"[CloudClient] Channel '{channel_type}' not logged in "
+                            f"(status={login_status}), forcing restart")
+        if skip_restart:
             logger.info(f"[CloudClient] Channel '{channel_type}' already running with same config, "
                         "skip restart, reporting status only")
             threading.Thread(
@@ -255,7 +262,14 @@ class CloudClient(LinkAIClient):
             ).start()
         else:
             existing_ch = self.channel_mgr.get_channel(channel_type)
-            if existing_ch and not cred_changed:
+            needs_restart = cred_changed or not existing_ch
+            if not needs_restart and channel_type in ("weixin", "wx"):
+                login_status = getattr(existing_ch, "login_status", "")
+                if login_status != "logged_in":
+                    needs_restart = True
+                    logger.info(f"[CloudClient] Channel '{channel_type}' not logged in "
+                                f"(status={login_status}), forcing restart")
+            if existing_ch and not needs_restart:
                 logger.info(f"[CloudClient] Channel '{channel_type}' already running with same config, "
                             "skip restart, reporting status only")
                 threading.Thread(
@@ -473,6 +487,19 @@ class CloudClient(LinkAIClient):
             session_id = f"session_{session_id}"
         logger.info(f"[CloudClient] on_chat: session={session_id}, channel={channel_type}, query={query[:80]}")
 
+        # Intercept cow/slash commands before the agent runs
+        try:
+            from plugins import PluginManager
+            mgr = PluginManager()
+            instance = mgr.instances.get("COW_CLI")
+            if instance and hasattr(instance, "execute"):
+                result = instance.execute(query, session_id=session_id)
+                if result is not None:
+                    send_chunk_fn({"chunk_type": "content", "delta": result, "segment_id": 0})
+                    return
+        except Exception as e:
+            logger.warning(f"[CloudClient] cow_cli intercept failed: {e}")
+
         svc = self.chat_service
         if svc is None:
             raise RuntimeError("ChatService not available")
@@ -615,9 +642,9 @@ def get_deployment_id() -> str:
 
 
 def get_website_base_url() -> str:
-    """Return the public URL prefix that maps to the workspace websites/ dir.
+    """Return the URL prefix that maps to the workspace websites/ dir.
 
-    Returns empty string when cloud deployment is not configured.
+    Do nothing when in local env.
     """
     deployment_id = get_deployment_id()
     if not deployment_id:
@@ -634,6 +661,42 @@ def get_website_base_url() -> str:
     return f"https://app.{domain}/{deployment_id}"
 
 
+# Subdir under websites/ used by the send tool
+COW_SEND_WEB_SUBDIR = "cow-send"
+
+
+def copy_send_file(src_path: str, workspace_root: str) -> str:
+    """Copy *src_path* into ``websites/cow-send/`` and return its URL.
+
+    Returns empty string in local env.
+    """
+    import shutil
+    import uuid
+
+    from common.utils import expand_path
+
+    base = get_website_base_url()
+    if not base or not src_path or not os.path.isfile(src_path):
+        return ""
+    ws = os.path.abspath(expand_path(workspace_root))
+    send_dir = os.path.join(ws, "websites", COW_SEND_WEB_SUBDIR)
+    try:
+        os.makedirs(send_dir, exist_ok=True)
+    except OSError:
+        return ""
+    ext = os.path.splitext(src_path)[1].lower()
+    if len(ext) > 12 or not ext.replace(".", "").isalnum():
+        ext = ""
+    dest_name = f"{uuid.uuid4().hex}{ext}"
+    dest_path = os.path.join(send_dir, dest_name)
+    try:
+        shutil.copy2(src_path, dest_path)
+    except OSError as e:
+        logger.warning(f"[cloud] copy_send_file: copy failed: {e}")
+        return ""
+    return f"{base}/{COW_SEND_WEB_SUBDIR}/{dest_name}"
+
+
 def build_website_prompt(workspace_dir: str) -> list:
     """Build system prompt lines for cloud website/file sharing rules.
 
@@ -654,8 +717,8 @@ def build_website_prompt(workspace_dir: str) -> list:
         f"   - 例如: `websites/my-app/index.html` → `{base_url}/my-app/index.html`",
         "",
         "2. **生成文件分享** (PPT、PDF、图片、音视频等): 当你为用户生成了需要下载或查看的文件时，**可以**将文件保存到 `websites/` 目录中",
-        f"   - 例如: 生成的PPT保存到 `websites/files/report.pptx` → 下载链接为 `{base_url}/files/report.pptx`",
-        "   - 你仍然可以同时使用 `send` 工具发送文件（在飞书、钉钉等IM渠道中有效），但**必须同时在回复文本中提供下载链接**作为兜底，因为部分渠道（如网页端）无法通过 send 接收本地文件",
+        f"  - 例如: 生成的PPT保存到 `websites/files/report.pptx` → 下载链接为 `{base_url}/files/report.pptx`",
+        "   - 你仍然可以同时使用 `send` 工具发送文件（在微信、飞书、钉钉、web等渠道中有效），但**必须同时在回复文本中提供下载链接**作为兜底，因为部分渠道无法通过 send 接收本地文件",
         "",
         "3. **必须发送链接**: 无论是网页还是文件，生成后**必须将完整的访问/下载链接直接写在回复文本中发送给用户**",
         "",

common/const.py

@@ -124,6 +124,10 @@ DOUBAO_SEED_2_PRO = "doubao-seed-2-0-pro-260215"
 DOUBAO_SEED_2_LITE = "doubao-seed-2-0-lite-260215"
 DOUBAO_SEED_2_MINI = "doubao-seed-2-0-mini-260215"
 
+# ModelScope(魔搭社区)
+QWEN3_235B_A22B_INSTRUCT_2507 = "Qwen/Qwen3-235B-A22B-Instruct-2507"
+QWEN3_5_27B = "Qwen/Qwen3.5-27B"
+
 # 其他模型
 WEN_XIN = "wenxin"
 WEN_XIN_4 = "wenxin-4"
@@ -135,11 +139,14 @@ MODELSCOPE = "modelscope"
 
 GITEE_AI_MODEL_LIST = ["Yi-34B-Chat", "InternVL2-8B", "deepseek-coder-33B-instruct", "InternVL2.5-26B", "Qwen2-VL-72B", "Qwen2.5-32B-Instruct", "glm-4-9b-chat", "codegeex4-all-9b", "Qwen2.5-Coder-32B-Instruct", "Qwen2.5-72B-Instruct", "Qwen2.5-7B-Instruct", "Qwen2-72B-Instruct", "Qwen2-7B-Instruct", "code-raccoon-v1", "Qwen2.5-14B-Instruct"]
 
-MODELSCOPE_MODEL_LIST = ["LLM-Research/c4ai-command-r-plus-08-2024","mistralai/Mistral-Small-Instruct-2409","mistralai/Ministral-8B-Instruct-2410","mistralai/Mistral-Large-Instruct-2407",
-                          "Qwen/Qwen2.5-Coder-32B-Instruct","Qwen/Qwen2.5-Coder-14B-Instruct","Qwen/Qwen2.5-Coder-7B-Instruct","Qwen/Qwen2.5-72B-Instruct","Qwen/Qwen2.5-32B-Instruct","Qwen/Qwen2.5-14B-Instruct","Qwen/Qwen2.5-7B-Instruct","Qwen/QwQ-32B-Preview",
-                          "LLM-Research/Llama-3.3-70B-Instruct","opencompass/CompassJudger-1-32B-Instruct","Qwen/QVQ-72B-Preview","LLM-Research/Meta-Llama-3.1-405B-Instruct","LLM-Research/Meta-Llama-3.1-8B-Instruct","Qwen/Qwen2-VL-7B-Instruct","LLM-Research/Meta-Llama-3.1-70B-Instruct",
-                          "Qwen/Qwen2.5-14B-Instruct-1M","Qwen/Qwen2.5-7B-Instruct-1M","Qwen/Qwen2.5-VL-3B-Instruct","Qwen/Qwen2.5-VL-7B-Instruct","Qwen/Qwen2.5-VL-72B-Instruct","deepseek-ai/DeepSeek-R1-Distill-Llama-70B","deepseek-ai/DeepSeek-R1-Distill-Llama-8B","deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
-                          "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B","deepseek-ai/DeepSeek-R1-Distill-Qwen-7B","deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B","deepseek-ai/DeepSeek-R1","deepseek-ai/DeepSeek-V3","Qwen/QwQ-32B"]
+MODELSCOPE_MODEL_LIST = ["deepseek-ai/DeepSeek-R1-0528", "deepseek-ai/DeepSeek-R1-Distill-Llama-70B", "deepseek-ai/DeepSeek-R1-Distill-Llama-8B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B", "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
+                         "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "deepseek-ai/DeepSeek-V3.2", "LLM-Research/c4ai-command-r-plus-08-2024", "LLM-Research/Llama-4-Maverick-17B-128E-Instruct", "meituan-longcat/LongCat-Flash-Lite", "MiniMax/MiniMax-M1-80k", "MiniMax/MiniMax-M2.5", "mistralai/Ministral-8B-Instruct-2410",
+                         "mistralai/Mistral-Large-Instruct-2407", "mistralai/Mistral-Small-Instruct-2409", "moonshotai/Kimi-K2.5", "MusePublic/Qwen-Image-Edit", "opencompass/CompassJudger-1-32B-Instruct", "OpenGVLab/InternVL3_5-241B-A28B",
+                         "Qwen/QVQ-72B-Preview", "Qwen/Qwen-Image-Edit", "Qwen/Qwen3-0.6B", "Qwen/Qwen3-1.7B", "Qwen/Qwen3-14B", "Qwen/Qwen3-235B-A22B", "Qwen/Qwen3-235B-A22B-Instruct-2507", "Qwen/Qwen3-235B-A22B-Thinking-2507", "Qwen/Qwen3-30B-A3B", "Qwen/Qwen3-30B-A3B-Thinking-2507",
+                         "Qwen/Qwen3-32B", "Qwen/Qwen3-4B", "Qwen/Qwen3-8B", "Qwen/Qwen3-Coder-30B-A3B-Instruct", "Qwen/Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-Next-80B-A3B-Instruct", "Qwen/Qwen3-Next-80B-A3B-Thinking", "Qwen/Qwen3-VL-235B-A22B-Instruct", "Qwen/Qwen3-VL-8B-Instruct",
+                         "Qwen/Qwen3-VL-8B-Thinking", "Qwen/Qwen3.5-122B-A10B", "Qwen/Qwen3.5-27B", "Qwen/Qwen3.5-35B-A3B", "Qwen/Qwen3.5-397B-A17B", "Qwen/QwQ-32B", "Qwen/QwQ-32B-Preview", "Shanghai_AI_Laboratory/Intern-S1", "Shanghai_AI_Laboratory/Intern-S1-mini",
+                         "stepfun-ai/Step-3.5-Flash", "XiaomiMiMo/MiMo-V2-Flash", "ZhipuAI/GLM-4.7-Flash", "ZhipuAI/GLM-5"]
+
 
 MODEL_LIST = [
               # Claude

common/log.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+import io
 
 
 def _reset_logger(log):
@@ -9,7 +10,10 @@ def _reset_logger(log):
         del handler
     log.handlers.clear()
     log.propagate = False
-    console_handle = logging.StreamHandler(sys.stdout)
+    stdout = sys.stdout
+    if hasattr(stdout, "buffer"):
+        stdout = io.TextIOWrapper(stdout.buffer, encoding="utf-8", errors="replace", line_buffering=True)
+    console_handle = logging.StreamHandler(stdout)
     console_handle.setFormatter(
         logging.Formatter(
             "[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - %(message)s",

config.py

@@ -408,7 +408,7 @@ def get_root():
 
 
 def read_file(path):
-    with open(path, mode="r", encoding="utf-8") as f:
+    with open(path, mode="r", encoding="utf-8-sig") as f:
         return f.read()
 
 

docker/Dockerfile.latest

@@ -4,32 +4,54 @@ LABEL maintainer="foo@bar.com"
 ARG TZ='Asia/Shanghai'
 
 ARG CHATGPT_ON_WECHAT_VER
+# Set to "false" to skip Playwright/Chromium and produce a smaller image
+ARG INSTALL_BROWSER=true
+# Set to "true" to use China mirrors for apt / pip / playwright (faster in CN)
+ARG USE_CN_MIRROR=false
 
-RUN echo /etc/apt/sources.list
-# RUN sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list
+ENV PLAYWRIGHT_BROWSERS_PATH=/app/ms-playwright
 ENV BUILD_PREFIX=/app
 
+# Optionally switch apt and pip to China mirrors
+RUN if [ "$USE_CN_MIRROR" = "true" ]; then \
+        sed -i 's/deb.debian.org/mirrors.tuna.tsinghua.edu.cn/g' /etc/apt/sources.list; \
+        pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/; \
+    fi
+
 ADD . ${BUILD_PREFIX}
 
+# All heavy installs + user creation in ONE layer to avoid chown duplication
 RUN apt-get update \
-    &&apt-get install -y --no-install-recommends bash ffmpeg espeak libavcodec-extra\
+    && apt-get install -y --no-install-recommends bash ffmpeg espeak libavcodec-extra \
     && cd ${BUILD_PREFIX} \
     && cp config-template.json config.json \
     && /usr/local/bin/python -m pip install --no-cache --upgrade pip \
     && pip install --no-cache -r requirements.txt \
     && pip install --no-cache -r requirements-optional.txt \
-    && pip install azure-cognitiveservices-speech
+    && pip install --no-cache -e . \
+    && if [ "$INSTALL_BROWSER" = "true" ]; then \
+        apt-get install -y --no-install-recommends fonts-wqy-zenhei \
+        && pip install --no-cache "playwright==1.52.0" \
+        && python -m playwright install-deps chromium \
+        && mkdir -p /app/ms-playwright \
+        && if [ "$USE_CN_MIRROR" = "true" ]; then \
+            PLAYWRIGHT_DOWNLOAD_HOST=https://registry.npmmirror.com/-/binary/playwright \
+            python -m playwright install chromium; \
+        else \
+            python -m playwright install chromium; \
+        fi; \
+    fi \
+    && rm -rf /var/lib/apt/lists/* \
+    && mkdir -p /home/agent/cow \
+    && groupadd -r agent \
+    && useradd -r -g agent -s /bin/bash -d /home/agent agent \
+    && chown -R agent:agent /home/agent ${BUILD_PREFIX} /usr/local/lib
 
 WORKDIR ${BUILD_PREFIX}
 
 ADD docker/entrypoint.sh /entrypoint.sh
 
 RUN chmod +x /entrypoint.sh \
-    && mkdir -p /home/agent/cow \
-    && groupadd -r agent \
-    && useradd -r -g agent -s /bin/bash -d /home/agent agent \
-    && chown -R agent:agent /home/agent ${BUILD_PREFIX} /usr/local/lib
-
-USER agent
+    && chown agent:agent /entrypoint.sh
 
 ENTRYPOINT ["/entrypoint.sh"]

docker/entrypoint.sh

@@ -43,9 +43,15 @@ fi
 # fi
 
 
-# go to prefix dir
+# fix ownership of mounted volumes then drop to non-root user
+if [ "$(id -u)" = "0" ]; then
+    mkdir -p /home/agent/cow
+    chown agent:agent /home/agent/cow
+    exec su agent -s /bin/bash -c "cd $CHATGPT_ON_WECHAT_PREFIX && $CHATGPT_ON_WECHAT_EXEC"
+fi
+
+# fallback: already running as agent
 cd $CHATGPT_ON_WECHAT_PREFIX
-# excute
 $CHATGPT_ON_WECHAT_EXEC
 
 

docs/channels/weixin.mdx

@@ -1,9 +1,9 @@
 ---
 title: 微信
-description: 将 CowAgent 接入个人微信
+description: 将 CowAgent 接入个人微信（基于官方接口）
 ---
 
-> 接入个人微信，扫码登录即可使用，支持文本、图片、语音、文件、视频等消息的收发。
+> 接入个人微信，扫码登录即可使用，支持文本、图片、语音、文件、视频等消息的私聊收发。通过微信官方API进行接入，无安全风险，接入后会在会话中新增一个机器人助手，不影响当前账号的使用。
 
 ## 一、配置和运行
 

docs/commands/general.mdx

@@ -0,0 +1,115 @@
+---
+title: 常用命令
+description: 查看状态、管理配置和上下文等常用命令
+---
+
+以下命令支持在对话中使用 `/` 前缀，也支持在终端中使用 `cow` 前缀（部分命令仅对话可用）。
+
+<Tip>
+  在 Web 控制台中输入 `/` 会自动弹出命令提示，支持键盘上下选择和 Tab 补全。
+</Tip>
+
+## help
+
+显示所有可用命令的帮助信息。
+
+```text
+/help
+```
+
+## status
+
+查看当前会话和服务的运行状态，包括进程信息、模型配置、会话消息数量和已加载技能数量。
+
+```text
+/status
+```
+
+输出示例：
+
+```
+🐮 CowAgent Status
+
+Process: PID 12345 | Running 2h 15m
+Version: 2.0.4
+Channel: web
+Model:   MiniMax-M2.5
+Mode:    agent
+
+Session: 12 messages | 8 skills loaded
+```
+
+## config
+
+查看或修改运行时配置。修改后立即生效，无需重启服务。
+
+**查看所有可配置项：**
+
+```text
+/config
+```
+
+**查看单个配置项：**
+
+```text
+/config model
+```
+
+**修改配置项：**
+
+```text
+/config model deepseek-chat
+```
+
+**支持修改的配置项：**
+
+| 配置项 | 说明 | 示例值 |
+| --- | --- | --- |
+| `model` | AI 模型名称 | `deepseek-chat` |
+| `agent_max_context_tokens` | 最大上下文 tokens | `40000` |
+| `agent_max_context_turns` | 最大上下文记忆轮次 | `30` |
+| `agent_max_steps` | 单次任务最大决策步数 | `15` |
+
+<Note>
+  修改 `model` 时，系统会自动匹配对应的模型调用方式。配置会写入 `config.json` 并持久保存。
+</Note>
+
+## context
+
+查看当前会话的上下文信息，包括消息数量、内容长度等统计。
+
+```text
+/context
+```
+
+**清空当前会话上下文：**
+
+```text
+/context clear
+```
+
+<Tip>
+  清空上下文后，Agent 会"忘记"之前的对话内容，适用于切换话题或释放上下文空间。
+</Tip>
+
+## logs
+
+查看最近的服务日志，默认显示最近 20 行，最多 50 行。
+
+```text
+/logs
+```
+
+**指定行数：**
+
+```text
+/logs 50
+```
+
+## version
+
+显示当前 CowAgent 版本号。
+
+```text
+/version
+```

docs/commands/index.mdx

@@ -0,0 +1,86 @@
+---
+title: 命令总览
+description: CowAgent 命令系统 — 终端 CLI 和对话命令
+---
+
+CowAgent 提供两种命令交互方式：
+
+- **终端CLI** — 在系统终端中执行 `cow <命令>`，用于服务管理、技能管理等运维操作
+- **对话命令** — 在对话中输入 `/<命令>` 或 `cow <命令>`，用于查看状态、管理技能、调整配置等
+
+## 终端命令
+
+通过一键安装脚本部署后，`cow` 命令会自动可用。手动安装的用户需要在项目根目录下额外执行：
+
+```bash
+pip install -e .
+```
+
+安装后即可在任意位置使用 `cow` 命令：
+
+```bash
+cow help
+```
+
+输出示例：
+
+```
+CowAgent CLI
+
+Usage: cow <command>
+
+Service:
+  start     Start the CowAgent service
+  stop      Stop the CowAgent service
+  restart   Restart the CowAgent service
+  update    Update code and restart service
+  status    Show service status
+  logs      View service logs
+
+Skills:
+  skill     Manage skills (list / search / install / uninstall ...)
+
+Others:
+  help      Show this help message
+  version   Show version
+```
+
+## 对话命令
+
+在 Web 控制台或任意接入渠道的对话中，支持输入以 `/` 开头的命令：
+
+| 命令 | 说明 |
+| --- | --- |
+| `/help` | 显示命令帮助 |
+| `/status` | 查看服务状态和配置 |
+| `/config` | 查看或修改运行时配置 |
+| `/skill` | 管理技能（安装、卸载、启用、禁用等） |
+| `/context` | 查看当前会话上下文信息 |
+| `/context clear` | 清空当前会话上下文 |
+| `/logs` | 查看最近日志 |
+| `/version` | 显示版本号 |
+
+<Tip>
+  对话命令中 `/start`、`/stop`、`/restart` 等服务管理命令会提示到终端中执行，因为它们涉及进程操作。
+</Tip>
+
+## 命令对照表
+
+以下是各命令在终端和对话中的可用性：
+
+| 命令 | 终端 (`cow`) | 对话 (`/`) |
+| --- | :---: | :---: |
+| help | ✓ | ✓ |
+| version | ✓ | ✓ |
+| status | ✓ | ✓ |
+| logs | ✓ | ✓ |
+| config | ✗ | ✓ |
+| context | — | ✓ |
+| skill (子命令) | ✓ | ✓ |
+| start / stop / restart | ✓ | ✗ |
+| update | ✓ | ✗ |
+| install-browser | ✓ | ✗ |
+
+<Note>
+  `context` 在终端中仅提示到对话中使用。`config` 仅支持在对话中修改。
+</Note>

docs/commands/process.mdx

@@ -0,0 +1,134 @@
+---
+title: 进程管理
+description: 使用 cow 命令管理 CowAgent 进程的启动、停止、重启、更新等操作
+---
+
+进程管理命令用于控制 CowAgent 后台进程的生命周期。这些命令仅在终端中可用。
+
+## start
+
+启动 CowAgent 服务。默认以后台进程方式运行，并自动跟踪日志输出。
+
+```bash
+cow start
+```
+
+**选项：**
+
+| 选项 | 说明 |
+| --- | --- |
+| `-f`, `--foreground` | 前台运行，不以后台守护进程方式启动 |
+| `--no-logs` | 启动后不自动跟踪日志 |
+
+## stop
+
+停止正在运行的 CowAgent 服务。
+
+```bash
+cow stop
+```
+
+## restart
+
+重启 CowAgent 服务（先停止再启动）。
+
+```bash
+cow restart
+```
+
+**选项：**
+
+| 选项 | 说明 |
+| --- | --- |
+| `--no-logs` | 重启后不自动跟踪日志 |
+
+## update
+
+更新代码并重启服务。自动执行以下流程：
+
+1. 拉取最新代码（`git pull`）
+2. 停止当前服务
+3. 更新 Python 依赖
+4. 重新安装 CLI
+5. 启动服务
+
+```bash
+cow update
+```
+
+<Warning>
+  如果 `git pull` 失败（如存在本地未提交的修改），更新会中止，服务不受影响。
+</Warning>
+
+## status
+
+查看 CowAgent 服务运行状态，包括进程信息、版本号、当前配置的模型和通道。
+
+```bash
+cow status
+```
+
+输出示例：
+
+```
+🐮 CowAgent Status
+  Status:   ● Running (PID: 12345)
+  Version:  2.0.4
+  Channel:  web
+  Model:    MiniMax-M2.5
+  Mode:     agent
+```
+
+## logs
+
+查看服务日志。
+
+```bash
+cow logs
+```
+
+**选项：**
+
+| 选项 | 说明 | 默认值 |
+| --- | --- | --- |
+| `-f`, `--follow` | 持续跟踪日志输出 | 否 |
+| `-n`, `--lines` | 显示最近 N 行 | 50 |
+
+示例：
+
+```bash
+# 查看最近 100 行日志
+cow logs -n 100
+
+# 持续跟踪日志
+cow logs -f
+```
+
+## install-browser
+
+安装 Playwright 和 Chromium 浏览器，用于启用 [浏览器工具](/tools/browser)。
+
+```bash
+cow install-browser
+```
+
+<Tip>
+  仅在需要使用浏览器工具（如网页浏览、截图等）时才需要安装。
+</Tip>
+
+## run.sh 兼容
+
+如果未安装 Cow CLI，也可以使用 `run.sh` 脚本管理服务：
+
+| cow 命令 | run.sh 等效命令 |
+| --- | --- |
+| `cow start` | `./run.sh start` |
+| `cow stop` | `./run.sh stop` |
+| `cow restart` | `./run.sh restart` |
+| `cow update` | `./run.sh update` |
+| `cow status` | `./run.sh status` |
+| `cow logs` | `./run.sh logs` |
+
+<Note>
+  推荐使用 `cow` 命令，它提供更简洁的语法和更丰富的功能。通过一键安装脚本部署时 `cow` 命令会自动安装。
+</Note>

docs/commands/skill.mdx

@@ -0,0 +1,218 @@
+---
+title: 技能管理
+description: 通过命令安装、卸载、启用、禁用和管理技能
+---
+
+技能管理命令用于安装、查询和管理 CowAgent 的技能。在对话中使用 `/skill <子命令>`，在终端中使用 `cow skill <子命令>`。
+
+## list
+
+列出已安装的技能及其状态。
+
+<CodeGroup>
+```text 对话
+/skill list
+```
+
+```bash 终端
+cow skill list
+```
+</CodeGroup>
+
+输出示例：
+
+```
+📦 已安装的技能 (3/4)
+
+✅ pptx
+   Use this skill any time a .pptx file is involved…
+   来源: cowhub
+
+✅ skill-creator
+   Create, install, or update skills…
+   来源: builtin
+
+⏸️ image-vision (已禁用)
+   图片理解和视觉分析
+   来源: builtin
+```
+
+**浏览技能广场**（查看 Hub 上所有可安装的技能）：
+
+<CodeGroup>
+```text 对话
+/skill list --remote
+```
+
+```bash 终端
+cow skill list --remote
+```
+</CodeGroup>
+
+**选项：**
+
+| 选项 | 说明 | 默认值 |
+| --- | --- | --- |
+| `--remote`, `-r` | 浏览 Skill Hub 远程技能列表 | 否 |
+| `--page` | 远程列表分页页码 | 1 |
+
+## search
+
+在技能广场中搜索技能。
+
+<CodeGroup>
+```text 对话
+/skill search pptx
+```
+
+```bash 终端
+cow skill search pptx
+```
+</CodeGroup>
+
+## install
+
+安装技能。通过统一的 `install` 命令，可一键安装来自 **Cow 技能广场、GitHub、ClawHub** 以及任意 URL（zip 压缩包、SKILL.md 链接）上的技能，无需手动下载和配置。
+
+**从 Cow 技能广场安装（推荐）：**
+
+<CodeGroup>
+```text 对话
+/skill install pptx
+```
+
+```bash 终端
+cow skill install pptx
+```
+</CodeGroup>
+
+**从 GitHub 安装：**
+
+<CodeGroup>
+```text 对话
+# 安装仓库中的所有技能（自动扫描包含 SKILL.md 的子目录）
+/skill install larksuite/cli
+
+# 指定子目录，只安装单个技能
+/skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# 使用 # 指定子目录
+/skill install larksuite/cli#skills/lark-minutes
+```
+
+```bash 终端
+# 安装仓库中的所有技能（自动扫描包含 SKILL.md 的子目录）
+cow skill install larksuite/cli
+
+# 指定子目录，只安装单个技能
+cow skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# 使用 # 指定子目录
+cow skill install larksuite/cli#skills/lark-minutes
+```
+</CodeGroup>
+
+支持完整的 GitHub URL 和 `owner/repo` 简写。对于 mono-repo（一个仓库中包含多个技能），不指定子目录时会自动发现并批量安装所有技能；指定子目录时只安装该目录下的技能。
+
+**从 ClawHub 安装：**
+
+<CodeGroup>
+```text 对话
+/skill install clawhub:baidu-search
+```
+
+```bash 终端
+cow skill install clawhub:baidu-search
+```
+</CodeGroup>
+
+**从 URL 安装：**
+
+<CodeGroup>
+```text 对话
+# 从 zip 压缩包安装（支持单个或批量）
+/skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# 从 SKILL.md 链接安装
+/skill install https://example.com/path/to/SKILL.md
+```
+
+```bash 终端
+# 从 zip 压缩包安装（支持单个或批量）
+cow skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# 从 SKILL.md 链接安装
+cow skill install https://example.com/path/to/SKILL.md
+```
+</CodeGroup>
+
+支持从 zip / tar.gz 压缩包 URL 安装，解压后自动扫描包含 `SKILL.md` 的目录，支持单个或批量安装。也支持直接从 `SKILL.md` 文件链接安装，会自动解析技能名称和描述。
+
+安装成功后会显示技能名称、描述和来源，例如：
+
+```
+✅ baidu-search
+   百度搜索：使用百度搜索引擎检索信息…
+   来源: clawhub
+```
+
+## uninstall
+
+卸载已安装的技能。
+
+<CodeGroup>
+```text 对话
+/skill uninstall pptx
+```
+
+```bash 终端
+cow skill uninstall pptx
+```
+</CodeGroup>
+
+<Warning>
+  卸载操作会删除技能目录下的所有文件，此操作不可恢复。
+</Warning>
+
+## enable / disable
+
+启用或禁用技能，禁用后技能不会被 Agent 调用。
+
+<CodeGroup>
+```text 对话
+/skill enable pptx
+/skill disable pptx
+```
+
+```bash 终端
+cow skill enable pptx
+cow skill disable pptx
+```
+</CodeGroup>
+
+## info
+
+查看已安装技能的详细信息，包括 `SKILL.md` 内容预览。
+
+<CodeGroup>
+```text 对话
+/skill info pptx
+```
+
+```bash 终端
+cow skill info pptx
+```
+</CodeGroup>
+
+## 技能来源
+
+安装的技能会记录来源信息，可通过 `/skill list` 查看：
+
+| 来源标识 | 说明 |
+| --- | --- |
+| `builtin` | 项目内置技能 |
+| `cowhub` | 从 CowAgent Skill Hub 安装 |
+| `github` | 从 GitHub URL 直接安装 |
+| `clawhub` | 从 ClawHub 安装 |
+| `url` | 从 SKILL.md URL 安装 |
+| `local` | 本地创建的技能 |

docs/docs.json

@@ -106,14 +106,17 @@
                   "tools/bash",
                   "tools/send",
                   "tools/memory",
-                  "tools/env-config"
+                  "tools/env-config",
+                  "tools/web-fetch",
+                  "tools/scheduler"
                 ]
               },
               {
                 "group": "可选工具",
                 "pages": [
                   "tools/web-search",
-                  "tools/scheduler"
+                  "tools/vision",
+                  "tools/browser"
                 ]
               }
             ]
@@ -125,15 +128,8 @@
                 "group": "技能系统",
                 "pages": [
                   "skills/index",
-                  "skills/skill-creator"
-                ]
-              },
-              {
-                "group": "内置技能",
-                "pages": [
-                  "skills/image-vision",
-                  "skills/linkai-agent",
-                  "skills/web-fetch"
+                  "skills/install",
+                  "skills/create"
                 ]
               }
             ]
@@ -144,7 +140,8 @@
               {
                 "group": "记忆系统",
                 "pages": [
-                  "memory"
+                  "memory/index",
+                  "memory/context"
                 ]
               }
             ]
@@ -167,6 +164,20 @@
               }
             ]
           },
+          {
+            "tab": "命令",
+            "groups": [
+              {
+                "group": "命令系统",
+                "pages": [
+                  "commands/index",
+                  "commands/process",
+                  "commands/skill",
+                  "commands/general"
+                ]
+              }
+            ]
+          },
           {
             "tab": "版本",
             "groups": [
@@ -254,14 +265,17 @@
                   "en/tools/bash",
                   "en/tools/send",
                   "en/tools/memory",
-                  "en/tools/env-config"
+                  "en/tools/env-config",
+                  "en/tools/web-fetch",
+                  "en/tools/scheduler"
                 ]
               },
               {
                 "group": "Optional Tools",
                 "pages": [
                   "en/tools/web-search",
-                  "en/tools/scheduler"
+                  "en/tools/vision",
+                  "en/tools/browser"
                 ]
               }
             ]
@@ -273,16 +287,9 @@
                 "group": "Skills System",
                 "pages": [
                   "en/skills/index",
+                  "en/skills/install",
                   "en/skills/skill-creator"
                 ]
-              },
-              {
-                "group": "Built-in Skills",
-                "pages": [
-                  "en/skills/image-vision",
-                  "en/skills/linkai-agent",
-                  "en/skills/web-fetch"
-                ]
               }
             ]
           },
@@ -292,7 +299,8 @@
               {
                 "group": "Memory System",
                 "pages": [
-                  "en/memory"
+                  "en/memory/index",
+                  "en/memory/context"
                 ]
               }
             ]
@@ -315,6 +323,20 @@
               }
             ]
           },
+          {
+            "tab": "Commands",
+            "groups": [
+              {
+                "group": "Command System",
+                "pages": [
+                  "en/commands/index",
+                  "en/commands/process",
+                  "en/commands/skill",
+                  "en/commands/chat"
+                ]
+              }
+            ]
+          },
           {
             "tab": "Releases",
             "groups": [
@@ -403,14 +425,16 @@
                   "ja/tools/send",
                   "ja/tools/memory",
                   "ja/tools/env-config",
-                  "ja/tools/browser"
+                  "ja/tools/web-fetch",
+                  "ja/tools/scheduler"
                 ]
               },
               {
                 "group": "オプションツール",
                 "pages": [
                   "ja/tools/web-search",
-                  "ja/tools/scheduler"
+                  "ja/tools/vision",
+                  "ja/tools/browser"
                 ]
               }
             ]
@@ -422,15 +446,8 @@
                 "group": "スキルシステム",
                 "pages": [
                   "ja/skills/index",
-                  "ja/skills/skill-creator"
-                ]
-              },
-              {
-                "group": "内蔵スキル",
-                "pages": [
-                  "ja/skills/image-vision",
-                  "ja/skills/linkai-agent",
-                  "ja/skills/web-fetch"
+                  "ja/skills/install",
+                  "ja/skills/create"
                 ]
               }
             ]
@@ -441,7 +458,8 @@
               {
                 "group": "メモリシステム",
                 "pages": [
-                  "ja/memory"
+                  "ja/memory/index",
+                  "ja/memory/context"
                 ]
               }
             ]
@@ -464,6 +482,20 @@
               }
             ]
           },
+          {
+            "tab": "コマンド",
+            "groups": [
+              {
+                "group": "コマンドシステム",
+                "pages": [
+                  "ja/commands/index",
+                  "ja/commands/process",
+                  "ja/commands/skill",
+                  "ja/commands/general"
+                ]
+              }
+            ]
+          },
           {
             "tab": "リリース",
             "groups": [

docs/en/README.md

@@ -20,13 +20,14 @@
 
 > CowAgent is both an out-of-the-box AI super assistant and a highly extensible Agent framework. You can extend it with new model interfaces, channels, built-in tools, and the Skills system to flexibly implement various customization needs.
 
-- ✅ **Autonomous Task Planning**: Understands complex tasks and autonomously plans execution, continuously thinking and invoking tools until goals are achieved. Supports accessing files, terminal, browser, schedulers, and other system resources via tools.
+- ✅ **Autonomous Task Planning**: Understands complex tasks and autonomously plans execution, continuously thinking and invoking tools until goals are achieved.
 - ✅ **Long-term Memory**: Automatically persists conversation memory to local files and databases, including core memory and daily memory, with keyword and vector retrieval support.
-- ✅ **Skills System**: Implements a Skills creation and execution engine with multiple built-in skills, and supports custom Skills development through natural language conversation.
+- ✅ **Skills System**: Implements a Skills creation and execution engine, supports installing skills from [Skill Hub](https://skills.cowagent.ai), GitHub, etc., or creating custom Skills through conversation.
+- ✅ **Tool System**: Built-in tools for file I/O, terminal execution, browser automation, scheduled tasks, messaging, and more — autonomously invoked by the Agent.
+- ✅ **CLI System**: Provides terminal commands and in-chat commands for process management, skill installation, configuration, and more.
 - ✅ **Multimodal Messages**: Supports parsing, processing, generating, and sending text, images, voice, files, and other message types.
 - ✅ **Multiple Model Support**: Supports OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, Kimi, Doubao, and other mainstream model providers.
 - ✅ **Multi-platform Deployment**: Runs on local computers or servers, integrable into WeChat, Web, Feishu, DingTalk, WeChat Official Account, and WeCom applications.
-- ✅ **Knowledge Base**: Integrates enterprise knowledge base capabilities via the [LinkAI](https://link-ai.tech) platform.
 
 ## Disclaimer
 
@@ -60,13 +61,19 @@ Full changelog: [Release Notes](https://docs.cowagent.ai/en/releases/overview)
 
 The project provides a one-click script for installation, configuration, startup, and management:
 
+**Linux / macOS:**
 ```bash
 bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
 ```
 
+**Windows (PowerShell):**
+```powershell
+irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+```
+
 After running, the Web service starts by default. Access `http://localhost:9899/chat` to chat.
 
-Script usage: [One-click Install](https://docs.cowagent.ai/en/guide/quick-start)
+Script usage: [One-click Install](https://docs.cowagent.ai/en/guide/quick-start). After installation, you can also use `cow start`, `cow stop`, and other [CLI commands](https://docs.cowagent.ai/en/commands/index) to manage the service.
 
 ### Manual Installation
 
@@ -84,7 +91,25 @@ pip3 install -r requirements.txt
 pip3 install -r requirements-optional.txt   # optional but recommended
 ```
 
-**3. Configure**
+**3. Install Cow CLI (recommended)**
+
+```bash
+pip3 install -e .
+```
+
+After installation, use `cow` commands to manage the service (start, stop, update, etc.) and skills. See [Command Docs](https://docs.cowagent.ai/en/commands/index).
+
+**4. Install browser (optional)**
+
+If you need the Agent to operate a browser (visit web pages, fill forms, etc.):
+
+```bash
+cow install-browser
+```
+
+This auto-installs `playwright` and Chromium. See [Browser Tool Docs](https://docs.cowagent.ai/en/tools/browser).
+
+**5. Configure**
 
 ```bash
 cp config-template.json config.json
@@ -92,13 +117,25 @@ cp config-template.json config.json
 
 Fill in your model API key and channel type in `config.json`. See the [configuration docs](https://docs.cowagent.ai/en/guide/manual-install) for details.
 
-**4. Run**
+**6. Run**
 
 ```bash
-python3 app.py
+cow start              # recommended, requires Cow CLI
+python3 app.py         # or run directly
 ```
 
-For server background run:
+For server deployment, use `cow` commands to manage the service:
+
+```bash
+cow start              # start in background
+cow stop               # stop service
+cow restart            # restart service
+cow status             # check running status
+cow logs               # view logs
+cow update             # pull latest code and restart
+```
+
+Or use the traditional way:
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
@@ -195,7 +232,7 @@ FAQs: <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
 
 ## 🛠️ Contributing
 
-Welcome to add new channels, referring to the [Feishu channel](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py) as an example. Also welcome to contribute new Skills, referring to the [Skill Creator docs](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md).
+Welcome to add new channels, referring to the [Feishu channel](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py) as an example. Also welcome to contribute new Skills, see the [Skill Creation docs](https://docs.cowagent.ai/en/skills/create).
 
 ## ✉ Contact
 

docs/en/commands/general.mdx

@@ -0,0 +1,101 @@
+---
+title: General Commands
+description: View status, manage config, and control context with commonly used commands
+---
+
+The following commands can be used in chat with the `/` prefix or in the terminal with the `cow` prefix (some are chat-only).
+
+<Tip>
+  In the Web console, typing `/` brings up an autocomplete menu with keyboard navigation and Tab completion.
+</Tip>
+
+## help
+
+Show help information for all available commands.
+
+```text
+/help
+```
+
+## status
+
+View current session and service status, including process info, model configuration, message count, and loaded skills.
+
+```text
+/status
+```
+
+## config
+
+View or modify runtime configuration. Changes take effect immediately without restarting.
+
+**View all configurable items:**
+
+```text
+/config
+```
+
+**View a single item:**
+
+```text
+/config model
+```
+
+**Modify a config item:**
+
+```text
+/config model deepseek-chat
+```
+
+**Configurable items:**
+
+| Item | Description | Example |
+| --- | --- | --- |
+| `model` | AI model name | `deepseek-chat` |
+| `agent_max_context_tokens` | Max context tokens | `40000` |
+| `agent_max_context_turns` | Max context memory turns | `30` |
+| `agent_max_steps` | Max decision steps per task | `15` |
+
+<Note>
+  When changing `model`, the system automatically matches the corresponding model API. Configuration is persisted to `config.json`.
+</Note>
+
+## context
+
+View current session context statistics, including message count and content length.
+
+```text
+/context
+```
+
+**Clear current session context:**
+
+```text
+/context clear
+```
+
+<Tip>
+  Clearing context makes the Agent "forget" previous conversation, useful for switching topics or freeing context space.
+</Tip>
+
+## logs
+
+View recent service logs. Shows the last 20 lines by default, up to 50.
+
+```text
+/logs
+```
+
+**Specify line count:**
+
+```text
+/logs 50
+```
+
+## version
+
+Show the current CowAgent version.
+
+```text
+/version
+```

docs/en/commands/index.mdx

@@ -0,0 +1,84 @@
+---
+title: Commands Overview
+description: CowAgent command system — Terminal CLI and chat commands
+---
+
+CowAgent provides two ways to interact via commands:
+
+- **Terminal CLI** — Run `cow <command>` in your system terminal for service management, skill management, and other operations
+- **Chat Commands** — Type `/<command>` or `cow <command>` in any conversation to check status, manage skills, adjust configuration, etc.
+
+## Cow CLI
+
+After deploying with the one-click install script, the `cow` command is automatically available. For manual installations, run:
+
+```bash
+pip install -e .
+```
+
+Then use the `cow` command from anywhere:
+
+```bash
+cow help
+```
+
+Example output:
+
+```
+🐮 CowAgent CLI
+
+Usage: cow <command>
+
+Service:
+  start     Start the CowAgent service
+  stop      Stop the CowAgent service
+  restart   Restart the CowAgent service
+  update    Update code and restart service
+  status    Show service status
+  logs      View service logs
+
+Skills:
+  skill     Manage skills (list / search / install / uninstall ...)
+
+Others:
+  help      Show this help message
+  version   Show version
+```
+
+## Chat Commands
+
+In the Web console or any connected channel, type `/` to see command suggestions. Supported commands:
+
+| Command | Description |
+| --- | --- |
+| `/help` | Show command help |
+| `/status` | View service status and configuration |
+| `/config` | View or modify runtime configuration |
+| `/skill` | Manage skills (install, uninstall, enable, disable, etc.) |
+| `/context` | View current session context info |
+| `/context clear` | Clear current session context |
+| `/logs` | View recent logs |
+| `/version` | Show version number |
+
+<Tip>
+  Service management commands like `/start`, `/stop`, `/restart` will prompt you to use them in the terminal instead, as they involve process operations.
+</Tip>
+
+## Command Availability
+
+| Command | Terminal (`cow`) | Chat (`/`) |
+| --- | :---: | :---: |
+| help | ✓ | ✓ |
+| version | ✓ | ✓ |
+| status | ✓ | ✓ |
+| logs | ✓ | ✓ |
+| config | ✗ | ✓ |
+| context | — | ✓ |
+| skill (subcommands) | ✓ | ✓ |
+| start / stop / restart | ✓ | ✗ |
+| update | ✓ | ✗ |
+| install-browser | ✓ | ✗ |
+
+<Note>
+  `context` only shows a hint in the terminal to use it in chat. `config` is only available in chat.
+</Note>

docs/en/commands/process.mdx

@@ -0,0 +1,123 @@
+---
+title: Process Management
+description: Manage CowAgent process lifecycle with cow commands
+---
+
+Process management commands control the CowAgent background process. These commands are only available in the terminal.
+
+## start
+
+Start the CowAgent service. Runs as a background daemon by default and automatically tails logs.
+
+```bash
+cow start
+```
+
+**Options:**
+
+| Option | Description |
+| --- | --- |
+| `-f`, `--foreground` | Run in foreground, not as a background daemon |
+| `--no-logs` | Don't tail logs after starting |
+
+## stop
+
+Stop the running CowAgent service.
+
+```bash
+cow stop
+```
+
+## restart
+
+Restart the CowAgent service (stop then start).
+
+```bash
+cow restart
+```
+
+**Options:**
+
+| Option | Description |
+| --- | --- |
+| `--no-logs` | Don't tail logs after restart |
+
+## update
+
+Update code and restart the service. Automatically performs:
+
+1. Pull latest code (`git pull`)
+2. Stop current service
+3. Update Python dependencies
+4. Reinstall CLI
+5. Start service
+
+```bash
+cow update
+```
+
+<Warning>
+  If `git pull` fails (e.g., uncommitted local changes), the update aborts and the service remains unaffected.
+</Warning>
+
+## status
+
+Check CowAgent service status, including process info, version, and current model/channel configuration.
+
+```bash
+cow status
+```
+
+## logs
+
+View service logs.
+
+```bash
+cow logs
+```
+
+**Options:**
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `-f`, `--follow` | Continuously tail log output | No |
+| `-n`, `--lines` | Show last N lines | 50 |
+
+Examples:
+
+```bash
+# View last 100 lines
+cow logs -n 100
+
+# Continuously tail logs
+cow logs -f
+```
+
+## install-browser
+
+Install Playwright and Chromium browser for the [browser tool](/en/tools/browser).
+
+```bash
+cow install-browser
+```
+
+<Tip>
+  Only needed when using browser tools (web browsing, screenshots, etc.).
+</Tip>
+
+## run.sh Compatibility
+
+If Cow CLI is not installed, you can use `run.sh` to manage the service:
+
+| cow command | run.sh equivalent |
+| --- | --- |
+| `cow start` | `./run.sh start` |
+| `cow stop` | `./run.sh stop` |
+| `cow restart` | `./run.sh restart` |
+| `cow update` | `./run.sh update` |
+| `cow status` | `./run.sh status` |
+| `cow logs` | `./run.sh logs` |
+
+<Note>
+  The `cow` command is recommended — it provides cleaner syntax and richer features. It is automatically installed via the one-click install script.
+</Note>

docs/en/commands/skill.mdx

@@ -0,0 +1,192 @@
+---
+title: Skill Management
+description: Install, uninstall, enable, disable, and manage skills via commands
+---
+
+Skill management commands are used to install, query, and manage CowAgent skills. Use `/skill <subcommand>` in chat or `cow skill <subcommand>` in the terminal.
+
+## list
+
+List installed skills and their status.
+
+<CodeGroup>
+```text Chat
+/skill list
+```
+
+```bash Terminal
+cow skill list
+```
+</CodeGroup>
+
+**Browse the Skill Hub** (view all available skills):
+
+<CodeGroup>
+```text Chat
+/skill list --remote
+```
+
+```bash Terminal
+cow skill list --remote
+```
+</CodeGroup>
+
+**Options:**
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `--remote`, `-r` | Browse Skill Hub remote skill list | No |
+| `--page` | Page number for remote listing | 1 |
+
+## search
+
+Search for skills on the Skill Hub.
+
+<CodeGroup>
+```text Chat
+/skill search pptx
+```
+
+```bash Terminal
+cow skill search pptx
+```
+</CodeGroup>
+
+## install
+
+Install skills with a single `install` command from Cow Skill Hub, GitHub, ClawHub, or any URL (zip archives, SKILL.md links) — no manual download or configuration required.
+
+**From Skill Hub (recommended):**
+
+<CodeGroup>
+```text Chat
+/skill install pptx
+```
+
+```bash Terminal
+cow skill install pptx
+```
+</CodeGroup>
+
+**From GitHub:**
+
+<CodeGroup>
+```text Chat
+# Install all skills in a repo (auto-discovers subdirectories with SKILL.md)
+/skill install larksuite/cli
+
+# Specify a subdirectory to install a single skill
+/skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# Use # to specify a subdirectory
+/skill install larksuite/cli#skills/lark-minutes
+```
+
+```bash Terminal
+# Install all skills in a repo (auto-discovers subdirectories with SKILL.md)
+cow skill install larksuite/cli
+
+# Specify a subdirectory to install a single skill
+cow skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# Use # to specify a subdirectory
+cow skill install larksuite/cli#skills/lark-minutes
+```
+</CodeGroup>
+
+Supports full GitHub URLs and `owner/repo` shorthand. For mono-repos (multiple skills in one repository), omitting the subdirectory auto-discovers and batch-installs all skills; specifying a subdirectory installs only that skill.
+
+**From ClawHub:**
+
+<CodeGroup>
+```text Chat
+/skill install clawhub:baidu-search
+```
+
+```bash Terminal
+cow skill install clawhub:baidu-search
+```
+</CodeGroup>
+
+**From URL:**
+
+<CodeGroup>
+```text Chat
+# Install from a zip archive (single or batch)
+/skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# Install from a SKILL.md link
+/skill install https://example.com/path/to/SKILL.md
+```
+
+```bash Terminal
+# Install from a zip archive (single or batch)
+cow skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# Install from a SKILL.md link
+cow skill install https://example.com/path/to/SKILL.md
+```
+</CodeGroup>
+
+Supports installing from zip / tar.gz archive URLs — automatically extracts and discovers directories containing `SKILL.md`, with support for single or batch install. Also supports installing directly from a `SKILL.md` file URL, automatically parsing the skill name and description.
+
+## uninstall
+
+Uninstall an installed skill.
+
+<CodeGroup>
+```text Chat
+/skill uninstall pptx
+```
+
+```bash Terminal
+cow skill uninstall pptx
+```
+</CodeGroup>
+
+<Warning>
+  Uninstalling deletes all files in the skill directory. This action cannot be undone.
+</Warning>
+
+## enable / disable
+
+Enable or disable a skill. Disabled skills will not be invoked by the Agent.
+
+<CodeGroup>
+```text Chat
+/skill enable pptx
+/skill disable pptx
+```
+
+```bash Terminal
+cow skill enable pptx
+cow skill disable pptx
+```
+</CodeGroup>
+
+## info
+
+View details of an installed skill, including a preview of its `SKILL.md`.
+
+<CodeGroup>
+```text Chat
+/skill info pptx
+```
+
+```bash Terminal
+cow skill info pptx
+```
+</CodeGroup>
+
+## Skill Sources
+
+Installed skills track their origin, viewable via `/skill list`:
+
+| Source | Description |
+| --- | --- |
+| `builtin` | Built-in project skills |
+| `cowhub` | Installed from CowAgent Skill Hub |
+| `github` | Installed directly from a GitHub URL |
+| `clawhub` | Installed from ClawHub |
+| `url` | Installed from a SKILL.md URL |
+| `local` | Locally created skills |

docs/en/guide/manual-install.mdx

@@ -30,7 +30,25 @@ Optional dependencies (recommended):
 pip3 install -r requirements-optional.txt
 ```
 
-### 3. Configure
+### 3. Install Cow CLI
+
+Install the command-line tool for managing services and skills:
+
+```bash
+pip3 install -e .
+```
+
+Then use the `cow` command:
+
+```bash
+cow help
+```
+
+<Note>
+  This step is recommended. After installation you can use `cow start`, `cow stop`, `cow update` to manage the service, and `cow skill` to manage skills. Without the CLI, you can use `./run.sh` or `python3 app.py` to run.
+</Note>
+
+### 4. Configure
 
 Copy the config template and edit:
 
@@ -40,22 +58,32 @@ cp config-template.json config.json
 
 Fill in model API keys, channel type, and other settings in `config.json`. See the [model docs](/en/models/index) for details.
 
-### 4. Run
+### 5. Run
 
-**Local run:**
+**Using Cow CLI (recommended):**
+
+```bash
+cow start
+```
+
+**Or run locally in foreground:**
 
 ```bash
 python3 app.py
 ```
 
-By default, the Web service starts. Access `http://localhost:9899/chat` to chat.
+By default, the Web console starts. Access `http://localhost:9899` to chat.
 
-**Background run on server:**
+**Background run on server (without CLI):**
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
 ```
 
+<Tip>
+  If deploying on a server, open port `9899` in your firewall or security group to access the Web console. It's recommended to restrict access to specific IPs for security.
+</Tip>
+
 ## Docker Deployment
 
 Docker deployment does not require cloning source code or installing dependencies. For Agent mode, source deployment is recommended for broader system access.
@@ -84,6 +112,10 @@ sudo docker compose up -d
 sudo docker logs -f chatgpt-on-wechat
 ```
 
+<Tip>
+  If deploying on a server, open port `9899` in your firewall or security group to access the Web console. It's recommended to restrict access to specific IPs for security.
+</Tip>
+
 ## Core Configuration
 
 ```json

docs/en/guide/quick-start.mdx

@@ -9,31 +9,46 @@ Supports Linux, macOS, and Windows. Requires Python 3.7-3.12 (3.9 recommended).
 
 ## Install Command
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 The script automatically performs these steps:
 
 1. Check Python environment (requires Python 3.7+)
 2. Install required tools (git, curl, etc.)
 3. Clone project to `~/chatgpt-on-wechat`
-4. Install Python dependencies
+4. Install Python dependencies and Cow CLI
 5. Guided configuration for AI model and channel
 6. Start service
 
-By default, the Web service starts after installation. Access `http://localhost:9899/chat` to begin chatting.
+By default, the Web console starts after installation. Access `http://localhost:9899` to begin chatting.
 
 ## Management Commands
 
-After installation, use these commands to manage the service:
+After installation, use the `cow` command to manage the service:
 
 | Command | Description |
 | --- | --- |
-| `./run.sh start` | Start service |
-| `./run.sh stop` | Stop service |
-| `./run.sh restart` | Restart service |
-| `./run.sh status` | Check run status |
-| `./run.sh logs` | View real-time logs |
-| `./run.sh config` | Reconfigure |
-| `./run.sh update` | Update project code |
+| `cow start` | Start service |
+| `cow stop` | Stop service |
+| `cow restart` | Restart service |
+| `cow status` | Check run status |
+| `cow logs` | View real-time logs |
+| `cow update` | Update code and restart |
+| `cow install-browser` | Install browser tool dependencies |
+
+See the [Commands documentation](/en/commands/index) for more details.
+
+<Note>
+  If the `cow` command is not available, you can use `./run.sh <command>` (Linux/macOS) or `.\scripts\run.ps1 <command>` (Windows) as a fallback. Both are functionally equivalent.
+</Note>

docs/en/intro/index.mdx

@@ -28,6 +28,12 @@ CowAgent can proactively think and plan tasks, operate computers and external re
   <Card title="Multimodal Messages" icon="image" href="/en/channels/web">
     Supports parsing, processing, generating, and sending text, images, voice, files, and other message types.
   </Card>
+  <Card title="Tool System" icon="wrench" href="/en/tools/index">
+    Built-in tools for file I/O, terminal execution, browser automation, scheduled tasks, messaging, and more. The Agent autonomously invokes tools to accomplish complex tasks.
+  </Card>
+  <Card title="Command System" icon="terminal" href="/en/commands/index">
+    Provides terminal CLI and in-chat commands for process management, skill installation, configuration, context inspection, and other common operations.
+  </Card>
   <Card title="Multiple Model Support" icon="microchip" href="/en/models/index">
     Supports mainstream model providers including OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, Kimi, Doubao, and more.
   </Card>
@@ -40,9 +46,18 @@ CowAgent can proactively think and plan tasks, operate computers and external re
 
 Run the following command in your terminal for one-click install, configuration, and startup:
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 By default, the Web service starts after running. Access `http://localhost:9899/chat` to chat in the web interface.
 

docs/en/memory/context.mdx

@@ -0,0 +1,80 @@
+---
+title: Short-term Memory
+description: Conversation context — message management, compression strategies, and context operations
+---
+
+Conversation context is the Agent's short-term memory, containing all messages in the current session (user input, Agent replies, tool calls and results). Proper context management is critical for the Agent's reasoning quality and cost control.
+
+## Context Structure
+
+Each conversation turn consists of:
+
+```
+User message → Agent thinking → Tool call → Tool result → ... → Agent final reply
+```
+
+A single turn may include multiple tool calls (controlled by `agent_max_steps`). All tool calls and results are retained in context until compressed or trimmed.
+
+## Key Configuration
+
+| Parameter | Description | Default |
+| --- | --- | --- |
+| `agent_max_context_tokens` | Maximum context token budget | `50000` |
+| `agent_max_context_turns` | Maximum conversation turns in context | `20` |
+| `agent_max_steps` | Maximum decision steps per turn (tool call count) | `15` |
+
+Configurable via `config.json` or the `/config` chat command.
+
+## Compression Strategy
+
+When context exceeds limits, the system automatically compresses to free space. The process has multiple stages:
+
+### 1. Tool Result Truncation
+
+Before each decision loop, the system checks tool call results in historical turns. Results exceeding **20,000 characters** are truncated, keeping only the beginning and end with a truncation notice. Current turn results are not affected.
+
+### 2. Turn Trimming
+
+When conversation turns exceed `agent_max_context_turns`:
+
+- The **oldest half** of complete turns is trimmed (preserving tool call chain integrity)
+- Trimmed messages are summarized by LLM and **written to the daily memory file**
+- Remaining turns stay intact
+
+### 3. Token Budget Trimming
+
+After turn trimming, if tokens still exceed the budget:
+
+- **Fewer than 5 turns**: All turns undergo **text compression** — each turn keeps only the first user text and last Agent reply, removing intermediate tool call chains
+- **5 or more turns**: The **first half** of turns is trimmed again, with discarded content also written to memory
+
+### 4. Overflow Emergency Handling
+
+When the model API returns a context overflow error:
+
+1. All current messages are summarized and written to memory
+2. Aggressive trimming is applied (tool results limited to 10K chars, user text to 10K, max 5 turns)
+3. If still overflowing, the entire conversation context is cleared
+
+## Session Persistence
+
+Conversation messages are persisted to a local database, automatically restored after service restart. Restore strategy:
+
+- Restores the most recent **`max(3, max_context_turns / 6)`** turns
+- Only retains each turn's **user text and Agent final reply**, not intermediate tool call chains
+- Sessions older than **30 days** are automatically cleaned up
+
+## Commands
+
+Use these commands in chat to manage context:
+
+| Command | Description |
+| --- | --- |
+| `/context` | View current context statistics (message count, role distribution, total characters) |
+| `/context clear` | Clear current session context |
+| `/config agent_max_context_tokens 80000` | Adjust context token budget |
+| `/config agent_max_context_turns 30` | Adjust context turn limit |
+
+<Tip>
+  After clearing context, the Agent "forgets" previous conversation content. Content that was already written to long-term memory can still be retrieved via memory search.
+</Tip>

docs/en/memory/index.mdx

@@ -1,30 +1,39 @@
 ---
-title: Memory
-description: CowAgent long-term memory system
+title: Long-term Memory
+description: CowAgent long-term memory system — file persistence, automatic writing, and hybrid retrieval
 ---
 
-The memory system enables the Agent to remember important information over time, continuously accumulating experience, understanding user preferences, and truly achieving autonomous thinking and continuous growth.
+Long-term memory is stored in workspace files, persisting across sessions. The Agent loads historical memory on demand via retrieval tools during conversation, and automatically writes conversation summaries to long-term memory when context is trimmed.
 
 ## Memory Types
 
 ### Core Memory (MEMORY.md)
 
-Stored in `~/cow/MEMORY.md`, containing long-term user preferences, important decisions, key facts, and other information that doesn't fade over time. Automatically injected into the system prompt on every conversation turn as background knowledge.
+Stored in `~/cow/MEMORY.md`, containing long-term user preferences, important decisions, key facts, and other information that doesn't fade over time. The Agent reads and writes this file via tools to maintain long-term knowledge.
 
 ### Daily Memory (memory/YYYY-MM-DD.md)
 
-Stored in `~/cow/memory/` directory, named by date (e.g. `2026-03-08.md`), recording daily conversation summaries and key events. Files are only created on first write to avoid generating empty files.
+Stored in `~/cow/memory/` directory, named by date (e.g., `2026-03-08.md`), recording daily conversation summaries and key events. Files are only created on first write to avoid generating empty files.
 
-## Memory Writing
+## Automatic Writing
 
-The Agent automatically persists conversation content to daily memory through the following mechanisms:
+The Agent automatically persists conversation content to long-term memory through the following mechanisms:
 
-- **On context trimming** — When conversation turns or tokens exceed the configured limit, the oldest half of the context is trimmed in batch, and the discarded content is summarized by LLM into key information and written to the daily memory file
+- **On context trimming** — When conversation turns or tokens exceed the configured limit, the oldest half of the context is trimmed, and the discarded content is summarized by LLM into key information and written to the daily memory file
 - **Daily scheduled summary** — A full summary is automatically triggered at 23:55 every day, ensuring memory is preserved even on low-activity days (skipped if content hasn't changed)
 - **On API context overflow** — When the model API returns a context overflow error, the current conversation summary is saved as an emergency measure
 
 All memory writes run asynchronously in a background thread (LLM summarization + file writing), never blocking normal conversation replies.
 
+## Memory Retrieval
+
+The memory system supports hybrid retrieval modes:
+
+- **Keyword retrieval** — FTS5 full-text index matching with BM25 ranking
+- **Vector retrieval** — Embedding-based semantic similarity search, finds relevant memory even with different wording
+
+The Agent automatically triggers memory retrieval during conversation as needed, incorporating relevant historical information into context. Results are ranked by a combined score (default: 0.7 vector weight + 0.3 keyword weight). Daily memory scores decay over time (30-day half-life), while core memory does not decay.
+
 ## First Launch
 
 On first launch, the Agent will proactively ask the user for key information and save it to the workspace (default `~/cow`):
@@ -40,27 +49,10 @@ On first launch, the Agent will proactively ask the user for key information and
   <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
 </Frame>
 
-## Memory Retrieval
-
-The memory system supports hybrid retrieval modes:
-
-- **Keyword retrieval** — Match historical memory based on keywords
-- **Vector retrieval** — Semantic similarity search, finds relevant memory even with different wording
-
-The Agent automatically triggers memory retrieval during conversation as needed, incorporating relevant historical information into context. Core memory (`MEMORY.md`) is always injected into the system prompt, while daily memory is loaded on demand via retrieval.
-
 ## Configuration
 
-```json
-{
-  "agent_workspace": "~/cow",
-  "agent_max_context_tokens": 40000,
-  "agent_max_context_turns": 20
-}
-```
-
 | Parameter | Description | Default |
 | --- | --- | --- |
 | `agent_workspace` | Workspace path, memory files stored under this directory | `~/cow` |
-| `agent_max_context_tokens` | Max context tokens; when exceeded, half is trimmed and summarized into memory | `40000` |
-| `agent_max_context_turns` | Max context turns; when exceeded, half is trimmed and summarized into memory | `20` |
+| `agent_max_context_tokens` | Max context tokens; when exceeded, content is trimmed and summarized into memory | `50000` |
+| `agent_max_context_turns` | Max context turns; when exceeded, content is trimmed and summarized into memory | `20` |

docs/en/models/deepseek.mdx

@@ -3,7 +3,22 @@ title: DeepSeek
 description: DeepSeek model configuration
 ---
 
-Use OpenAI-compatible configuration:
+Option 1: Native integration (recommended):
+
+```json
+{
+  "model": "deepseek-chat",
+  "deepseek_api_key": "YOUR_API_KEY"
+}
+```
+
+| Parameter | Description |
+| --- | --- |
+| `model` | `deepseek-chat` (DeepSeek-V3.2, non-thinking mode), `deepseek-reasoner` (DeepSeek-R1, thinking mode) |
+| `deepseek_api_key` | Create at [DeepSeek Platform](https://platform.deepseek.com/api_keys) |
+| `deepseek_api_base` | Optional, defaults to `https://api.deepseek.com/v1`. Can be changed to a third-party proxy |
+
+Option 2: OpenAI-compatible configuration:
 
 ```json
 {
@@ -14,9 +29,4 @@ Use OpenAI-compatible configuration:
 }
 ```
 
-| Parameter | Description |
-| --- | --- |
-| `model` | `deepseek-chat` (DeepSeek-V3), `deepseek-reasoner` (DeepSeek-R1) |
-| `bot_type` | Must be `openai` (OpenAI-compatible mode) |
-| `open_ai_api_key` | Create at [DeepSeek Platform](https://platform.deepseek.com/api_keys) |
-| `open_ai_api_base` | DeepSeek platform BASE URL |
+

docs/en/skills/create.mdx

@@ -0,0 +1,58 @@
+---
+title: Create Skills
+description: Create custom skills through conversation
+---
+
+CowAgent includes a built-in Skill Creator that lets you quickly create, install, or update skills through natural language conversation.
+
+## Usage
+
+Simply describe the skill you want in a conversation, and the Agent will handle the creation:
+
+- Codify workflows as skills: "Create a skill from this deployment process"
+- Integrate third-party APIs: "Create a skill based on this API documentation"
+- Install remote skills: "Install xxx skill for me"
+
+## Creation Flow
+
+1. Tell the Agent what skill you want to create
+2. Agent automatically generates `SKILL.md` description and execution scripts
+3. Skill is saved to the workspace `~/cow/skills/` directory
+4. Agent will automatically recognize and use the skill in future conversations
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
+</Frame>
+
+## SKILL.md Format
+
+Created skills follow the standard SKILL.md format:
+
+```markdown
+---
+name: my-skill
+description: Brief description of the skill
+metadata:
+  emoji: 🔧
+  requires:
+    bins: ["curl"]
+    env: ["MY_API_KEY"]
+  primaryEnv: "MY_API_KEY"
+---
+
+# My Skill
+
+Detailed instructions...
+```
+
+| Field | Description |
+| --- | --- |
+| `name` | Skill name, must match directory name |
+| `description` | Skill description, Agent decides whether to invoke based on this |
+| `metadata.requires.bins` | Required system commands |
+| `metadata.requires.env` | Required environment variables |
+| `metadata.always` | Always load (default false) |
+
+<Tip>
+  See the [Skill Creator documentation](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md) for details.
+</Tip>

docs/en/skills/image-vision.mdx

@@ -1,31 +0,0 @@
----
-title: Image Vision
-description: Recognize images using OpenAI vision models
----
-
-Analyze image content using OpenAI's GPT-4 Vision API, understanding objects, text, colors, and other elements in images.
-
-## Dependencies
-
-| Dependency | Description |
-| --- | --- |
-| `OPENAI_API_KEY` | OpenAI API key |
-| `curl`, `base64` | System commands (usually pre-installed) |
-
-Configuration:
-
-- Configure `OPENAI_API_KEY` via the `env_config` tool
-- Or set `open_ai_api_key` in `config.json`
-
-## Supported Models
-
-- `gpt-4.1-mini` (recommended, cost-effective)
-- `gpt-4.1`
-
-## Usage
-
-Once configured, send an image to the Agent to automatically trigger image recognition.
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
-</Frame>

docs/en/skills/index.mdx

@@ -7,20 +7,17 @@ Skills provide infinite extensibility for the Agent. Each Skill consists of a de
 
 The difference between Skills and Tools: Tools are atomic operations implemented in code (e.g., file read/write, command execution), while Skills are high-level workflows based on description files that can combine multiple Tools to complete complex tasks.
 
-## Built-in Skills
+## Getting Skills
 
-Located in the project `skills/` directory, automatically enabled based on dependency conditions:
+CowAgent offers multiple ways to acquire skills:
 
-| Skill | Description | Dependencies |
-| --- | --- | --- |
-| [`skill-creator`](/en/skills/skill-creator) | Create custom skills through conversation | None |
-| [`openai-image-vision`](/en/skills/image-vision) | Recognize images using OpenAI vision models | `OPENAI_API_KEY` |
-| [`linkai-agent`](/en/skills/linkai-agent) | Integrate LinkAI platform agents | `LINKAI_API_KEY` |
-| [`web-fetch`](/en/skills/web-fetch) | Fetch web page text content | `curl` (enabled by default) |
+- **Cow Skill Hub** — Browse and install community skills via `/skill list --remote`
+- **GitHub** — Install directly from GitHub repositories, with batch install support
+- **ClawHub** — Install ClawHub skills via `/skill install clawhub:name`
+- **URL** — Install from zip archives or SKILL.md links
+- **Conversational creation** — Let the Agent create skills through natural language conversation
 
-## Custom Skills
-
-Created by users through conversation, stored in workspace (`~/cow/skills/`), can implement any complex business process and third-party system integration.
+See [Install Skills](/en/skills/install) and [Skill Management Commands](/en/commands/skill) for details. You can also [create skills](/en/skills/create) through conversation.
 
 ## Skill Loading Priority
 

docs/en/skills/install.mdx

@@ -0,0 +1,53 @@
+---
+title: Install Skills
+description: Install skills from multiple sources with a single command
+---
+
+CowAgent supports installing skills from **Cow Skill Hub, GitHub, ClawHub**, and any URL with a unified `install` command. Use `/skill install` in chat or `cow skill install` in the terminal.
+
+## From Skill Hub
+
+Browse the Skill Hub and install:
+
+```text
+/skill list --remote
+/skill install pptx
+```
+
+## From GitHub
+
+Supports batch install from repositories and single skill from subdirectories:
+
+```text
+/skill install larksuite/cli
+/skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+```
+
+## From ClawHub
+
+```text
+/skill install clawhub:baidu-search
+```
+
+## From URL
+
+Supports zip archives and SKILL.md file links:
+
+```text
+/skill install https://cdn.link-ai.tech/skills/pptx.zip
+/skill install https://example.com/path/to/SKILL.md
+```
+
+## Manage Skills
+
+```text
+/skill list                  # View installed skills
+/skill info pptx             # View skill details
+/skill enable pptx           # Enable a skill
+/skill disable pptx          # Disable a skill
+/skill uninstall pptx        # Uninstall a skill
+```
+
+<Tip>
+  All commands above work in the terminal by replacing `/skill` with `cow skill`. See [Skill Management Commands](/en/commands/skill) for full documentation.
+</Tip>

docs/en/skills/linkai-agent.mdx

@@ -1,47 +0,0 @@
----
-title: LinkAI Agent
-description: Integrate LinkAI platform multi-agent skill
----
-
-Use agents from the [LinkAI](https://link-ai.tech/) platform as Skills for multi-agent decision-making. The Agent intelligently selects based on agent names and descriptions, calling the corresponding application or workflow via `app_code`.
-
-## Dependencies
-
-| Dependency | Description |
-| --- | --- |
-| `LINKAI_API_KEY` | LinkAI platform API key, created in [Console](https://link-ai.tech/console/interface) |
-| `curl` | System command (usually pre-installed) |
-
-Configuration:
-
-- Configure `LINKAI_API_KEY` via the `env_config` tool
-- Or set `linkai_api_key` in `config.json`
-
-## Configure Agents
-
-Add available agents in `skills/linkai-agent/config.json`:
-
-```json
-{
-  "apps": [
-    {
-      "app_code": "G7z6vKwp",
-      "app_name": "LinkAI Customer Support",
-      "app_description": "Select this assistant only when the user needs help with LinkAI platform questions"
-    },
-    {
-      "app_code": "SFY5x7JR",
-      "app_name": "Content Creator",
-      "app_description": "Use this assistant only when the user needs to create images or videos"
-    }
-  ]
-}
-```
-
-## Usage
-
-Once configured, the Agent will automatically select the appropriate LinkAI agent based on the user's question.
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
-</Frame>

docs/en/skills/skill-creator.mdx

@@ -1,31 +0,0 @@
----
-title: Skill Creator
-description: Create custom skills through conversation
----
-
-Quickly create, install, or update skills through natural language conversation.
-
-## Dependencies
-
-No extra dependencies, always available.
-
-## Usage
-
-- Codify workflows as skills: "Create a skill from this deployment process"
-- Integrate third-party APIs: "Create a skill based on this API documentation"
-- Install remote skills: "Install xxx skill for me"
-
-## Creation Flow
-
-1. Tell the Agent what skill you want to create
-2. Agent automatically generates `SKILL.md` description and execution scripts
-3. Skill is saved to the workspace `~/cow/skills/` directory
-4. Agent will automatically recognize and use the skill in future conversations
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
-</Frame>
-
-<Tip>
-  See the [Skill Creator documentation](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md) for details.
-</Tip>

docs/en/skills/web-fetch.mdx

@@ -1,31 +0,0 @@
----
-title: Web Fetch
-description: Fetch web page text content
----
-
-Use curl to fetch web pages and extract readable text content. A lightweight web access method without browser automation.
-
-## Dependencies
-
-| Dependency | Description |
-| --- | --- |
-| `curl` | System command (usually pre-installed) |
-
-This skill has `always: true` set, enabled by default as long as the system has the `curl` command.
-
-## Usage
-
-Automatically invoked when the Agent needs to fetch content from a URL, no extra configuration needed.
-
-## Comparison with browser Tool
-
-| Feature | web-fetch (skill) | browser (tool) |
-| --- | --- | --- |
-| Dependencies | curl only | browser-use + playwright |
-| JS rendering | Not supported | Supported |
-| Page interaction | Not supported | Supports click, type, etc. |
-| Best for | Static page text | Dynamic web pages |
-
-<Tip>
-  For most web content retrieval scenarios, web-fetch is sufficient. Only use the browser tool when you need JS rendering or page interaction.
-</Tip>

docs/guide/manual-install.mdx

@@ -30,7 +30,41 @@ pip3 install -r requirements.txt
 pip3 install -r requirements-optional.txt
 ```
 
-### 3. 配置
+> 国内网络可使用镜像源加速：`pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple`
+
+### 3. 安装 Cow CLI
+
+安装命令行工具，用于管理服务和技能：
+
+```bash
+pip3 install -e .
+```
+
+安装后即可使用 `cow` 命令：
+
+```bash
+cow help
+```
+
+<Note>
+  此步骤为推荐操作。安装后可以使用 `cow start`、`cow stop`、`cow update` 等命令管理服务，也可以使用 `cow skill` 管理技能。如果不安装 CLI，可以使用 `./run.sh` 或 `python3 app.py` 运行。
+</Note>
+
+### 3.1 安装浏览器工具（可选）
+
+如需使用浏览器工具（控制浏览器访问网页、填写表单等），运行：
+
+```bash
+cow install-browser
+```
+
+该命令会自动安装 Playwright 和 Chromium 浏览器。详细说明参考 [浏览器工具文档](/tools/browser)。
+
+<Note>
+  浏览器工具依赖较重（~300MB），如不需要可跳过，不影响其他功能正常使用。
+</Note>
+
+### 4. 配置
 
 复制配置文件模板并编辑：
 
@@ -40,9 +74,15 @@ cp config-template.json config.json
 
 在 `config.json` 中填写模型 API Key 和通道类型等配置，详细说明参考各 [模型文档](/models/minimax)。
 
-### 4. 运行
+### 5. 运行
 
-**本地运行：**
+**使用 Cow CLI 运行（推荐）：**
+
+```bash
+cow start
+```
+
+**或者本地前台运行：**
 
 ```bash
 python3 app.py
@@ -50,7 +90,7 @@ python3 app.py
 
 运行后默认启动 Web 控制台，访问 `http://localhost:9899` 开始对话和管理Agent。
 
-**服务器后台运行：**
+**服务器后台运行（不使用 CLI 时）：**
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
@@ -94,28 +134,44 @@ sudo docker logs -f chatgpt-on-wechat
 
 ## 核心配置项
 
-```json
-{
-  "channel_type": "web",
-  "model": "MiniMax-M2.5",
-  "agent": true,
-  "agent_workspace": "~/cow",
-  "agent_max_context_tokens": 40000,
-  "agent_max_context_turns": 30,
-  "agent_max_steps": 15
-}
-```
+<Tabs>
+  <Tab title="源码部署（config.json）">
+    ```json
+    {
+      "channel_type": "web",
+      "model": "MiniMax-M2.7",
+      "agent": true,
+      "agent_workspace": "~/cow",
+      "agent_max_context_tokens": 40000,
+      "agent_max_context_turns": 30,
+      "agent_max_steps": 15
+    }
+    ```
+  </Tab>
+  <Tab title="Docker 部署（docker-compose.yml）">
+    ```yaml
+    environment:
+      CHANNEL_TYPE: 'web'
+      MODEL: 'MiniMax-M2.7'
+      MINIMAX_API_KEY: 'your-api-key'
+      AGENT: 'True'
+      AGENT_MAX_CONTEXT_TOKENS: 40000
+      AGENT_MAX_CONTEXT_TURNS: 30
+      AGENT_MAX_STEPS: 15
+    ```
+  </Tab>
+</Tabs>
 
-| 参数 | 说明 | 默认值 |
-| --- | --- | --- |
-| `channel_type` | 接入渠道类型 | `web` |
-| `model` | 模型名称 | `MiniMax-M2.5` |
-| `agent` | 是否启用 Agent 模式 | `true` |
-| `agent_workspace` | Agent 工作空间路径 | `~/cow` |
-| `agent_max_context_tokens` | 最大上下文 tokens | `40000` |
-| `agent_max_context_turns` | 最大上下文记忆轮次 | `30` |
-| `agent_max_steps` | 单次任务最大决策步数 | `15` |
+| 参数 | 环境变量 | 说明 | 默认值 |
+| --- | --- | --- | --- |
+| `channel_type` | `CHANNEL_TYPE` | 接入渠道类型 | `web` |
+| `model` | `MODEL` | 模型名称 | `MiniMax-M2.5` |
+| `agent` | `AGENT` | 是否启用 Agent 模式 | `true` |
+| `agent_workspace` | - | Agent 工作空间路径 | `~/cow` |
+| `agent_max_context_tokens` | `AGENT_MAX_CONTEXT_TOKENS` | 最大上下文 tokens | `40000` |
+| `agent_max_context_turns` | `AGENT_MAX_CONTEXT_TURNS` | 最大上下文记忆轮次 | `30` |
+| `agent_max_steps` | `AGENT_MAX_STEPS` | 单次任务最大决策步数 | `15` |
 
 <Tip>
-  全部配置项可在项目 [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) 文件中查看。
+  全部配置项可在项目 [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) 文件中查看。Docker 部署时，配置项名称需转为大写环境变量格式。
 </Tip>

docs/guide/quick-start.mdx

@@ -9,16 +9,25 @@ description: 使用脚本一键安装和管理 CowAgent
 
 ## 安装命令
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 脚本自动执行以下流程：
 
 1. 检查 Python 环境（需要 Python 3.7+）
 2. 安装必要工具（git、curl 等）
 3. 克隆项目代码到 `~/chatgpt-on-wechat`
-4. 安装 Python 依赖
+4. 安装 Python 依赖和 Cow CLI
 5. 引导配置 AI 模型和通信渠道
 6. 启动服务
 
@@ -26,14 +35,20 @@ bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
 
 ## 管理命令
 
-安装完成后，可使用以下命令管理服务：
+安装完成后，使用 `cow` CLI 管理服务：
 
 | 命令 | 说明 |
 | --- | --- |
-| `./run.sh start` | 启动服务 |
-| `./run.sh stop` | 停止服务 |
-| `./run.sh restart` | 重启服务 |
-| `./run.sh status` | 查看运行状态 |
-| `./run.sh logs` | 查看实时日志 |
-| `./run.sh config` | 重新配置 |
-| `./run.sh update` | 更新项目代码 |
+| `cow start` | 启动服务 |
+| `cow stop` | 停止服务 |
+| `cow restart` | 重启服务 |
+| `cow status` | 查看运行状态 |
+| `cow logs` | 查看实时日志 |
+| `cow update` | 更新代码并重启 |
+| `cow install-browser` | 安装浏览器工具依赖 |
+
+更多命令和用法参考 [命令文档](/commands/index)。
+
+<Note>
+  如果 `cow` 命令不可用，也可以使用 `./run.sh <命令>`（Linux/macOS）或 `.\scripts\run.ps1 <命令>`（Windows）作为替代，功能等效。
+</Note>

docs/guide/upgrade.mdx

@@ -3,20 +3,25 @@ title: 更新升级
 description: CowAgent 的升级方式说明
 ---
 
-## 脚本升级（推荐）
+## 命令升级（推荐）
 
-如果使用 `run.sh` 管理服务，执行以下命令即可一键升级：
+使用 `cow update` 一键完成代码更新和服务重启：
 
 ```bash
-./run.sh update
+cow update
 ```
 
 该命令会自动完成以下流程：
 
-1. 停止当前运行的服务
-2. 拉取最新代码
-3. 重新检查依赖
-4. 启动服务
+1. 拉取最新代码（`git pull`）
+2. 停止当前服务
+3. 更新 Python 依赖
+4. 重新安装 CLI
+5. 启动服务
+
+<Note>
+  如果未安装 Cow CLI，也可以使用 `./run.sh update` 完成相同操作。
+</Note>
 
 ## 手动升级
 
@@ -25,15 +30,19 @@ description: CowAgent 的升级方式说明
 ```bash
 git pull
 pip3 install -r requirements.txt
+pip3 install -e .
 ```
 
 更新完成后重启服务：
 
 ```bash
-# 如果使用 run.sh 管理
+# 使用 Cow CLI
+cow restart
+
+# 或使用 run.sh
 ./run.sh restart
 
-# 如果使用 nohup 直接运行
+# 或使用 nohup 直接运行
 kill $(ps -ef | grep app.py | grep -v grep | awk '{print $2}')
 nohup python3 app.py & tail -f nohup.out
 ```

docs/intro/index.mdx

@@ -22,7 +22,7 @@ CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、
 
 <CardGroup cols={2}>
   <Card title="复杂任务规划" icon="brain" href="/intro/architecture">
-    能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持通过工具操作访问文件、终端、浏览器、定时任务等系统资源。
+    能够理解复杂任务并自主规划执行，持续思考和调用各类工具和技能直到完成目标。
   </Card>
   <Card title="长期记忆" icon="database" href="/memory">
     自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索。
@@ -33,10 +33,16 @@ CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、
   <Card title="多模态消息" icon="image" href="/channels/web">
     支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作。
   </Card>
-  <Card title="多模型接入" icon="microchip" href="/models/index">
+  <Card title="工具系统" icon="wrench" href="/tools/index">
+    内置文件读写、终端执行、浏览器操作、定时任务、消息发送等工具，Agent 可自主调用工具完成复杂任务。
+  </Card>
+  <Card title="命令系统" icon="terminal" href="/commands/index">
+    提供终端 CLI 和对话中的命令，支持进程管理、技能安装、配置修改、上下文查看等常用操作。
+  </Card>
+  <Card title="多模型支持" icon="microchip" href="/models/index">
     支持 OpenAI, Claude, Gemini, DeepSeek, MiniMax, GLM, Qwen, Kimi, Doubao 等国内外主流模型厂商。
   </Card>
-  <Card title="多端部署" icon="server" href="/channels/weixin">
+  <Card title="多通道接入" icon="server" href="/channels/weixin">
     支持运行在本地计算机或服务器，可集成到微信、网页、飞书、钉钉、微信公众号、企业微信应用中使用。
   </Card>
 </CardGroup>
@@ -45,9 +51,18 @@ CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、
 
 在终端执行以下命令，即可一键安装、配置、启动 CowAgent：
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 运行后默认会启动 Web 控制台，通过访问 `http://localhost:9899` 可以在网页端进行对话、配置、应用通道接入等操作。
 

docs/ja/README.md

@@ -20,13 +20,14 @@
 
 > CowAgentは、すぐに使えるAIスーパーアシスタントであると同時に、高い拡張性を持つAgentフレームワークでもあります。新しいモデルインターフェース、チャネル、組み込みツール、Skillシステムを拡張することで、さまざまなカスタマイズニーズに柔軟に対応できます。
 
-- ✅ **自律的タスク計画**: 複雑なタスクを理解し、自律的に実行計画を立て、目標達成までツールを呼び出しながら継続的に思考します。ツールを通じてファイル、ターミナル、ブラウザ、スケジューラなどのシステムリソースにアクセスできます。
+- ✅ **自律的タスク計画**: 複雑なタスクを理解し、自律的に実行計画を立て、目標達成までツールを呼び出しながら継続的に思考します。
 - ✅ **長期記憶**: 会話の記憶をローカルファイルやデータベースに自動的に永続化します。コアメモリとデイリーメモリを含み、キーワード検索やベクトル検索に対応しています。
-- ✅ **Skillシステム**: Skillの作成・実行エンジンを実装しており、複数の組み込みSkillを備え、自然言語での会話を通じたカスタムSkillの開発もサポートしています。
+- ✅ **Skillシステム**: Skillの作成・実行エンジンを実装。[Skill Hub](https://skills.cowagent.ai)、GitHubなどからSkillをインストールでき、会話を通じたカスタムSkill作成もサポートしています。
+- ✅ **ツールシステム**: ファイル読み書き、ターミナル実行、ブラウザ操作、スケジュールタスク、メッセージ送信などの組み込みツールを提供。Agentが自律的に呼び出して複雑なタスクを完了します。
+- ✅ **CLIシステム**: ターミナルコマンドとチャットコマンドを提供し、プロセス管理、Skillインストール、設定変更などの操作をサポートします。
 - ✅ **マルチモーダルメッセージ**: テキスト、画像、音声、ファイルなど、さまざまなメッセージタイプの解析・処理・生成・送信に対応しています。
 - ✅ **複数モデル対応**: OpenAI、Claude、Gemini、DeepSeek、MiniMax、GLM、Qwen、Kimi、Doubaoなど、主要なモデルプロバイダーに対応しています。
 - ✅ **マルチプラットフォームデプロイ**: ローカルPCやサーバー上で実行でき、WeChat、Web、Feishu、DingTalk、WeChat公式アカウント、WeComアプリケーションに統合可能です。
-- ✅ **ナレッジベース**: [LinkAI](https://link-ai.tech) プラットフォームを通じて、企業向けナレッジベース機能を統合できます。
 
 ## 免責事項
 
@@ -60,13 +61,19 @@
 
 本プロジェクトは、インストール・設定・起動・管理をワンクリックで行えるスクリプトを提供しています：
 
+**Linux / macOS:**
 ```bash
 bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
 ```
 
+**Windows (PowerShell):**
+```powershell
+irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+```
+
 実行後、デフォルトでWebサービスが起動します。`http://localhost:9899/chat` にアクセスしてチャットを開始できます。
 
-スクリプトの使い方: [ワンクリックインストール](https://docs.cowagent.ai/en/guide/quick-start)
+スクリプトの使い方: [ワンクリックインストール](https://docs.cowagent.ai/ja/guide/quick-start)。インストール後は `cow start`、`cow stop` などの [CLI コマンド](https://docs.cowagent.ai/ja/commands/index)でサービスを管理できます。
 
 ### 手動インストール
 
@@ -84,7 +91,25 @@ pip3 install -r requirements.txt
 pip3 install -r requirements-optional.txt   # 任意ですが推奨
 ```
 
-**3. 設定**
+**3. Cow CLI のインストール（推奨）**
+
+```bash
+pip3 install -e .
+```
+
+インストール後、`cow` コマンドでサービス管理（起動、停止、更新など）やSkill管理ができます。[コマンドドキュメント](https://docs.cowagent.ai/ja/commands/index)を参照してください。
+
+**4. ブラウザのインストール（任意）**
+
+Agentにブラウザ操作（Webページへのアクセス、フォーム入力など）が必要な場合：
+
+```bash
+cow install-browser
+```
+
+`playwright` と Chromium を自動インストールします。[ブラウザツールドキュメント](https://docs.cowagent.ai/ja/tools/browser)を参照してください。
+
+**5. 設定**
 
 ```bash
 cp config-template.json config.json
@@ -92,13 +117,25 @@ cp config-template.json config.json
 
 `config.json` にモデルのAPIキーとチャネルタイプを記入してください。詳細は[設定ドキュメント](https://docs.cowagent.ai/en/guide/manual-install)を参照してください。
 
-**4. 実行**
+**6. 実行**
 
 ```bash
-python3 app.py
+cow start              # 推奨、Cow CLI が必要
+python3 app.py         # または直接実行
 ```
 
-サーバーでバックグラウンド実行する場合：
+サーバーデプロイでは、`cow` コマンドでサービスを管理できます：
+
+```bash
+cow start              # バックグラウンドで起動
+cow stop               # サービス停止
+cow restart            # サービス再起動
+cow status             # 実行状態を確認
+cow logs               # ログを表示
+cow update             # 最新コードを取得して再起動
+```
+
+または従来の方法で実行：
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
@@ -195,7 +232,7 @@ FAQ: <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
 
 ## 🛠️ コントリビューション
 
-新しいチャネルの追加を歓迎します。[Feishuチャネル](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py)を参考にしてください。また、新しいSkillのコントリビューションも歓迎します。[Skill Creatorドキュメント](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)を参照してください。
+新しいチャネルの追加を歓迎します。[Feishuチャネル](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py)を参考にしてください。また、新しいSkillのコントリビューションも歓迎します。[Skill作成ドキュメント](https://docs.cowagent.ai/ja/skills/create)を参照してください。
 
 ## ✉ お問い合わせ
 

docs/ja/commands/general.mdx

@@ -0,0 +1,101 @@
+---
+title: 汎用コマンド
+description: ステータスの確認、設定管理、コンテキスト制御などのよく使うコマンド
+---
+
+以下のコマンドはチャットで `/` プレフィックス、ターミナルで `cow` プレフィックスで使用できます（一部はチャット専用）。
+
+<Tip>
+  Web コンソールでは `/` を入力すると自動補完メニューが表示され、キーボードのナビゲーションと Tab 補完に対応しています。
+</Tip>
+
+## help
+
+使用可能なすべてのコマンドのヘルプ情報を表示します。
+
+```text
+/help
+```
+
+## status
+
+現在のセッションとサービスの実行状態を表示します。プロセス情報、モデル設定、メッセージ数、読み込み済みスキル数を含みます。
+
+```text
+/status
+```
+
+## config
+
+実行時設定の表示または変更を行います。変更は即座に反映され、再起動は不要です。
+
+**すべての設定項目を表示：**
+
+```text
+/config
+```
+
+**単一の設定項目を表示：**
+
+```text
+/config model
+```
+
+**設定項目を変更：**
+
+```text
+/config model deepseek-chat
+```
+
+**変更可能な設定項目：**
+
+| 項目 | 説明 | 例 |
+| --- | --- | --- |
+| `model` | AI モデル名 | `deepseek-chat` |
+| `agent_max_context_tokens` | 最大コンテキストトークン数 | `40000` |
+| `agent_max_context_turns` | 最大コンテキスト記憶ターン数 | `30` |
+| `agent_max_steps` | タスクごとの最大判断ステップ数 | `15` |
+
+<Note>
+  `model` を変更すると、システムが対応するモデル API を自動的にマッチングします。設定は `config.json` に永続的に保存されます。
+</Note>
+
+## context
+
+現在のセッションのコンテキスト統計情報を表示します。メッセージ数やコンテンツの長さを含みます。
+
+```text
+/context
+```
+
+**現在のセッションのコンテキストをクリア：**
+
+```text
+/context clear
+```
+
+<Tip>
+  コンテキストをクリアすると、Agent は以前の会話内容を「忘れます」。話題の切り替えやコンテキストスペースの解放に便利です。
+</Tip>
+
+## logs
+
+最近のサービスログを表示します。デフォルトでは最近の 20 行を表示し、最大 50 行です。
+
+```text
+/logs
+```
+
+**行数を指定：**
+
+```text
+/logs 50
+```
+
+## version
+
+現在の CowAgent のバージョンを表示します。
+
+```text
+/version
+```

docs/ja/commands/index.mdx

@@ -0,0 +1,84 @@
+---
+title: コマンド概要
+description: CowAgent コマンドシステム — ターミナル CLI とチャットコマンド
+---
+
+CowAgent は2つのコマンド操作方法を提供しています：
+
+- **ターミナル CLI** — システムターミナルで `cow <コマンド>` を実行し、サービス管理やスキル管理を行います
+- **チャットコマンド** — 会話で `/<コマンド>` または `cow <コマンド>` を入力し、ステータス確認、スキル管理、設定変更を行います
+
+## Cow CLI
+
+ワンクリックインストールスクリプトでデプロイすると、`cow` コマンドが自動的に利用可能になります。手動インストールの場合は以下を実行してください：
+
+```bash
+pip install -e .
+```
+
+インストール後、任意の場所で `cow` コマンドを使用できます：
+
+```bash
+cow help
+```
+
+出力例：
+
+```
+🐮 CowAgent CLI
+
+Usage: cow <command>
+
+Service:
+  start     Start the CowAgent service
+  stop      Stop the CowAgent service
+  restart   Restart the CowAgent service
+  update    Update code and restart service
+  status    Show service status
+  logs      View service logs
+
+Skills:
+  skill     Manage skills (list / search / install / uninstall ...)
+
+Others:
+  help      Show this help message
+  version   Show version
+```
+
+## チャットコマンド
+
+Web コンソールや接続されたチャネルの会話で `/` を入力すると、コマンドの候補が表示されます。使用可能なコマンド：
+
+| コマンド | 説明 |
+| --- | --- |
+| `/help` | コマンドヘルプを表示 |
+| `/status` | サービスの状態と設定を表示 |
+| `/config` | 実行時設定の表示・変更 |
+| `/skill` | スキル管理（インストール、アンインストール、有効化、無効化など） |
+| `/context` | 現在のセッションのコンテキスト情報を表示 |
+| `/context clear` | 現在のセッションのコンテキストをクリア |
+| `/logs` | 最近のログを表示 |
+| `/version` | バージョン番号を表示 |
+
+<Tip>
+  `/start`、`/stop`、`/restart` などのサービス管理コマンドは、プロセス操作を伴うため、ターミナルでの使用を案内します。
+</Tip>
+
+## コマンド対応表
+
+| コマンド | ターミナル (`cow`) | チャット (`/`) |
+| --- | :---: | :---: |
+| help | ✓ | ✓ |
+| version | ✓ | ✓ |
+| status | ✓ | ✓ |
+| logs | ✓ | ✓ |
+| config | ✗ | ✓ |
+| context | — | ✓ |
+| skill（サブコマンド） | ✓ | ✓ |
+| start / stop / restart | ✓ | ✗ |
+| update | ✓ | ✗ |
+| install-browser | ✓ | ✗ |
+
+<Note>
+  `context` はターミナルではチャットでの使用を案内するのみです。`config` はチャットでのみ利用可能です。
+</Note>

docs/ja/commands/process.mdx

@@ -0,0 +1,123 @@
+---
+title: プロセス管理
+description: cow コマンドで CowAgent プロセスのライフサイクルを管理
+---
+
+プロセス管理コマンドは CowAgent バックグラウンドプロセスのライフサイクルを制御します。これらのコマンドはターミナルでのみ使用可能です。
+
+## start
+
+CowAgent サービスを起動します。デフォルトではバックグラウンドデーモンとして実行され、自動的にログを表示します。
+
+```bash
+cow start
+```
+
+**オプション：**
+
+| オプション | 説明 |
+| --- | --- |
+| `-f`, `--foreground` | フォアグラウンドで実行（デーモンとして起動しない） |
+| `--no-logs` | 起動後にログを自動表示しない |
+
+## stop
+
+実行中の CowAgent サービスを停止します。
+
+```bash
+cow stop
+```
+
+## restart
+
+CowAgent サービスを再起動します（停止してから起動）。
+
+```bash
+cow restart
+```
+
+**オプション：**
+
+| オプション | 説明 |
+| --- | --- |
+| `--no-logs` | 再起動後にログを自動表示しない |
+
+## update
+
+コードを更新してサービスを再起動します。自動的に以下を実行します：
+
+1. 最新コードをプル（`git pull`）
+2. 現在のサービスを停止
+3. Python 依存パッケージを更新
+4. CLI を再インストール
+5. サービスを起動
+
+```bash
+cow update
+```
+
+<Warning>
+  `git pull` が失敗した場合（ローカルの未コミットの変更がある場合など）、更新は中止され、サービスには影響しません。
+</Warning>
+
+## status
+
+CowAgent サービスの実行状態を確認します。プロセス情報、バージョン、現在のモデルとチャネルの設定を含みます。
+
+```bash
+cow status
+```
+
+## logs
+
+サービスログを表示します。
+
+```bash
+cow logs
+```
+
+**オプション：**
+
+| オプション | 説明 | デフォルト値 |
+| --- | --- | --- |
+| `-f`, `--follow` | ログ出力を継続的に追跡 | いいえ |
+| `-n`, `--lines` | 最近の N 行を表示 | 50 |
+
+例：
+
+```bash
+# 最近の100行を表示
+cow logs -n 100
+
+# ログを継続的に追跡
+cow logs -f
+```
+
+## install-browser
+
+[ブラウザツール](/ja/tools/browser)のために Playwright と Chromium ブラウザをインストールします。
+
+```bash
+cow install-browser
+```
+
+<Tip>
+  ブラウザツール（Web ブラウジング、スクリーンショットなど）を使用する場合にのみ必要です。
+</Tip>
+
+## run.sh との互換性
+
+Cow CLI がインストールされていない場合は、`run.sh` でサービスを管理できます：
+
+| cow コマンド | run.sh 相当 |
+| --- | --- |
+| `cow start` | `./run.sh start` |
+| `cow stop` | `./run.sh stop` |
+| `cow restart` | `./run.sh restart` |
+| `cow update` | `./run.sh update` |
+| `cow status` | `./run.sh status` |
+| `cow logs` | `./run.sh logs` |
+
+<Note>
+  `cow` コマンドの使用を推奨します。よりシンプルな構文と豊富な機能を提供します。ワンクリックインストールスクリプトで自動的にインストールされます。
+</Note>

docs/ja/commands/skill.mdx

@@ -0,0 +1,192 @@
+---
+title: スキル管理
+description: コマンドでスキルのインストール、アンインストール、有効化、無効化、管理を行う
+---
+
+スキル管理コマンドは CowAgent のスキルのインストール、検索、管理に使用します。チャットでは `/skill <サブコマンド>`、ターミナルでは `cow skill <サブコマンド>` を使用します。
+
+## list
+
+インストール済みスキルとその状態を一覧表示します。
+
+<CodeGroup>
+```text チャット
+/skill list
+```
+
+```bash ターミナル
+cow skill list
+```
+</CodeGroup>
+
+**スキル広場を閲覧**（利用可能なすべてのスキルを表示）：
+
+<CodeGroup>
+```text チャット
+/skill list --remote
+```
+
+```bash ターミナル
+cow skill list --remote
+```
+</CodeGroup>
+
+**オプション：**
+
+| オプション | 説明 | デフォルト値 |
+| --- | --- | --- |
+| `--remote`, `-r` | Skill Hub のリモートスキルリストを閲覧 | いいえ |
+| `--page` | リモートリストのページ番号 | 1 |
+
+## search
+
+スキル広場でスキルを検索します。
+
+<CodeGroup>
+```text チャット
+/skill search pptx
+```
+
+```bash ターミナル
+cow skill search pptx
+```
+</CodeGroup>
+
+## install
+
+統一された `install` コマンドで、Cow スキル広場、GitHub、ClawHub、任意の URL（zip アーカイブ、SKILL.md リンク）からスキルをワンクリックでインストールできます。手動ダウンロードや設定は不要です。
+
+**スキル広場からインストール（推奨）：**
+
+<CodeGroup>
+```text チャット
+/skill install pptx
+```
+
+```bash ターミナル
+cow skill install pptx
+```
+</CodeGroup>
+
+**GitHub からインストール：**
+
+<CodeGroup>
+```text チャット
+# リポジトリ内のすべてのスキルをインストール（SKILL.md を含むサブディレクトリを自動検出）
+/skill install larksuite/cli
+
+# サブディレクトリを指定して単一スキルをインストール
+/skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# # でサブディレクトリを指定
+/skill install larksuite/cli#skills/lark-minutes
+```
+
+```bash ターミナル
+# リポジトリ内のすべてのスキルをインストール（SKILL.md を含むサブディレクトリを自動検出）
+cow skill install larksuite/cli
+
+# サブディレクトリを指定して単一スキルをインストール
+cow skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+
+# # でサブディレクトリを指定
+cow skill install larksuite/cli#skills/lark-minutes
+```
+</CodeGroup>
+
+完全な GitHub URL と `owner/repo` 省略形に対応しています。モノリポ（1つのリポジトリに複数のスキル）の場合、サブディレクトリを省略するとすべてのスキルを自動検出して一括インストールします。サブディレクトリを指定した場合は、そのスキルのみをインストールします。
+
+**ClawHub からインストール：**
+
+<CodeGroup>
+```text チャット
+/skill install clawhub:baidu-search
+```
+
+```bash ターミナル
+cow skill install clawhub:baidu-search
+```
+</CodeGroup>
+
+**URL からインストール：**
+
+<CodeGroup>
+```text チャット
+# zip アーカイブからインストール（単一またはバッチ）
+/skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# SKILL.md リンクからインストール
+/skill install https://example.com/path/to/SKILL.md
+```
+
+```bash ターミナル
+# zip アーカイブからインストール（単一またはバッチ）
+cow skill install https://cdn.link-ai.tech/skills/pptx.zip
+
+# SKILL.md リンクからインストール
+cow skill install https://example.com/path/to/SKILL.md
+```
+</CodeGroup>
+
+zip / tar.gz アーカイブ URL からのインストールに対応しており、自動的に解凍して `SKILL.md` を含むディレクトリを検出し、単一またはバッチインストールをサポートします。`SKILL.md` ファイルの URL から直接インストールすることもでき、スキル名と説明を自動的に解析します。
+
+## uninstall
+
+インストール済みスキルをアンインストールします。
+
+<CodeGroup>
+```text チャット
+/skill uninstall pptx
+```
+
+```bash ターミナル
+cow skill uninstall pptx
+```
+</CodeGroup>
+
+<Warning>
+  アンインストールするとスキルディレクトリ内のすべてのファイルが削除されます。この操作は元に戻せません。
+</Warning>
+
+## enable / disable
+
+スキルの有効化・無効化を行います。無効化されたスキルは Agent から呼び出されません。
+
+<CodeGroup>
+```text チャット
+/skill enable pptx
+/skill disable pptx
+```
+
+```bash ターミナル
+cow skill enable pptx
+cow skill disable pptx
+```
+</CodeGroup>
+
+## info
+
+インストール済みスキルの詳細情報を表示します。`SKILL.md` のプレビューを含みます。
+
+<CodeGroup>
+```text チャット
+/skill info pptx
+```
+
+```bash ターミナル
+cow skill info pptx
+```
+</CodeGroup>
+
+## スキルのソース
+
+インストールされたスキルはソース情報を記録しており、`/skill list` で確認できます：
+
+| ソース | 説明 |
+| --- | --- |
+| `builtin` | プロジェクト内蔵スキル |
+| `cowhub` | CowAgent Skill Hub からインストール |
+| `github` | GitHub URL から直接インストール |
+| `clawhub` | ClawHub からインストール |
+| `url` | SKILL.md URL からインストール |
+| `local` | ローカルで作成されたスキル |

docs/ja/guide/manual-install.mdx

@@ -30,7 +30,25 @@ pip3 install -r requirements.txt
 pip3 install -r requirements-optional.txt
 ```
 
-### 3. 設定
+### 3. Cow CLI をインストール
+
+サービスとスキルを管理するためのコマンドラインツールをインストールします：
+
+```bash
+pip3 install -e .
+```
+
+インストール後、`cow` コマンドが使用可能になります：
+
+```bash
+cow help
+```
+
+<Note>
+  このステップは推奨です。インストール後、`cow start`、`cow stop`、`cow update` でサービスを管理でき、`cow skill` でスキルを管理できます。CLI をインストールしない場合は、`./run.sh` または `python3 app.py` で実行できます。
+</Note>
+
+### 4. 設定
 
 設定テンプレートをコピーして編集します：
 
@@ -40,22 +58,32 @@ cp config-template.json config.json
 
 `config.json` にモデルの API キー、チャネルタイプ、その他の設定を入力します。詳細は[モデルのドキュメント](/ja/models/index)を参照してください。
 
-### 4. 実行
+### 5. 実行
 
-**ローカルで実行：**
+**Cow CLI を使用して実行（推奨）：**
+
+```bash
+cow start
+```
+
+**またはローカルでフォアグラウンド実行：**
 
 ```bash
 python3 app.py
 ```
 
-デフォルトではWebサービスが起動します。`http://localhost:9899/chat` にアクセスしてチャットできます。
+デフォルトでは Web コンソールが起動します。`http://localhost:9899` にアクセスしてチャットできます。
 
-**サーバーでバックグラウンド実行：**
+**サーバーでバックグラウンド実行（CLI 未使用時）：**
 
 ```bash
 nohup python3 app.py & tail -f nohup.out
 ```
 
+<Tip>
+  サーバーにデプロイする場合は、ファイアウォールまたはセキュリティグループでポート `9899` を開放して Web コンソールにアクセスできるようにしてください。セキュリティのため、特定の IP のみにアクセスを制限することを推奨します。
+</Tip>
+
 ## Docker によるデプロイ
 
 Docker デプロイでは、ソースコードのクローンや依存パッケージのインストールは不要です。Agent モードを使用する場合は、より広範なシステムアクセスが可能なソースコードによるデプロイを推奨します。
@@ -84,6 +112,10 @@ sudo docker compose up -d
 sudo docker logs -f chatgpt-on-wechat
 ```
 
+<Tip>
+  サーバーにデプロイする場合は、ファイアウォールまたはセキュリティグループでポート `9899` を開放して Web コンソールにアクセスできるようにしてください。セキュリティのため、特定の IP のみにアクセスを制限することを推奨します。
+</Tip>
+
 ## 主要な設定項目
 
 ```json

docs/ja/guide/quick-start.mdx

@@ -9,31 +9,46 @@ Linux、macOS、Windowsに対応しています。Python 3.7〜3.12が必要で
 
 ## インストールコマンド
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 スクリプトは以下の手順を自動的に実行します：
 
 1. Python環境の確認（Python 3.7以上が必要）
 2. 必要なツールのインストール（git、curlなど）
 3. プロジェクトを `~/chatgpt-on-wechat` にクローン
-4. Pythonの依存パッケージをインストール
+4. Pythonの依存パッケージと Cow CLI をインストール
 5. AIモデルとチャネルの対話式設定
 6. サービスの起動
 
-デフォルトでは、インストール後にWebサービスが起動します。`http://localhost:9899/chat` にアクセスしてチャットを開始できます。
+デフォルトでは、インストール後に Web コンソールが起動します。`http://localhost:9899` にアクセスしてチャットを開始できます。
 
 ## 管理コマンド
 
-インストール後、以下のコマンドでサービスを管理できます：
+インストール後、`cow` コマンドでサービスを管理できます：
 
 | コマンド | 説明 |
 | --- | --- |
-| `./run.sh start` | サービスを起動 |
-| `./run.sh stop` | サービスを停止 |
-| `./run.sh restart` | サービスを再起動 |
-| `./run.sh status` | 実行状態を確認 |
-| `./run.sh logs` | リアルタイムログを表示 |
-| `./run.sh config` | 再設定 |
-| `./run.sh update` | プロジェクトコードを更新 |
+| `cow start` | サービスを起動 |
+| `cow stop` | サービスを停止 |
+| `cow restart` | サービスを再起動 |
+| `cow status` | 実行状態を確認 |
+| `cow logs` | リアルタイムログを表示 |
+| `cow update` | コードを更新して再起動 |
+| `cow install-browser` | ブラウザツールの依存をインストール |
+
+詳細は[コマンドドキュメント](/ja/commands/index)を参照してください。
+
+<Note>
+  `cow` コマンドが利用できない場合は、`./run.sh <コマンド>`（Linux/macOS）または `.\scripts\run.ps1 <コマンド>`（Windows）で代替できます。機能は同等です。
+</Note>

docs/ja/guide/upgrade.mdx

@@ -3,20 +3,25 @@ title: アップデート
 description: CowAgent のアップグレード方法
 ---
 
-## スクリプトによるアップグレード（推奨）
+## コマンドによるアップグレード（推奨）
 
-`run.sh` でサービスを管理している場合、以下のコマンドでワンクリックアップグレードできます：
+`cow update` でコードの更新とサービスの再起動をワンクリックで実行できます：
 
 ```bash
-./run.sh update
+cow update
 ```
 
 このコマンドは以下のフローを自動的に実行します：
 
-1. 現在実行中のサービスを停止
-2. 最新コードをプル
-3. 依存関係を再チェック
-4. サービスを起動
+1. 最新コードをプル（`git pull`）
+2. 現在のサービスを停止
+3. Python 依存パッケージを更新
+4. CLI を再インストール
+5. サービスを起動
+
+<Note>
+  Cow CLI がインストールされていない場合は、`./run.sh update` でも同様の操作が可能です。
+</Note>
 
 ## 手動アップグレード
 
@@ -25,15 +30,19 @@ description: CowAgent のアップグレード方法
 ```bash
 git pull
 pip3 install -r requirements.txt
+pip3 install -e .
 ```
 
 更新完了後、サービスを再起動します：
 
 ```bash
-# run.sh で管理している場合
+# Cow CLI を使用
+cow restart
+
+# または run.sh を使用
 ./run.sh restart
 
-# nohup で直接実行している場合
+# または nohup で直接実行
 kill $(ps -ef | grep app.py | grep -v grep | awk '{print $2}')
 nohup python3 app.py & tail -f nohup.out
 ```

docs/ja/intro/index.mdx

@@ -28,6 +28,12 @@ CowAgent は自ら思考しタスクを計画し、コンピュータや外部
   <Card title="マルチモーダルメッセージ" icon="image" href="/ja/channels/web">
     テキスト、画像、音声、ファイルなどのメッセージタイプの解析、処理、生成、送信をサポートします。
   </Card>
+  <Card title="ツールシステム" icon="wrench" href="/ja/tools/index">
+    ファイル読み書き、ターミナル実行、ブラウザ操作、スケジュールタスク、メッセージ送信などの組み込みツールを提供。Agent が自律的にツールを呼び出して複雑なタスクを完了します。
+  </Card>
+  <Card title="コマンドシステム" icon="terminal" href="/ja/commands/index">
+    ターミナル CLI とチャット内コマンドを提供し、プロセス管理、Skill インストール、設定変更、コンテキスト確認などの一般的な操作をサポートします。
+  </Card>
   <Card title="複数モデル対応" icon="microchip" href="/ja/models/index">
     OpenAI、Claude、Gemini、DeepSeek、MiniMax、GLM、Qwen、Kimi、Doubao など、主要なモデルプロバイダーをサポートしています。
   </Card>
@@ -40,9 +46,18 @@ CowAgent は自ら思考しタスクを計画し、コンピュータや外部
 
 ターミナルで以下のコマンドを実行すると、ワンクリックでインストール、設定、起動ができます：
 
-```bash
-bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
-```
+<Tabs>
+  <Tab title="Linux / macOS">
+    ```bash
+    bash <(curl -fsSL https://cdn.link-ai.tech/code/cow/run.sh)
+    ```
+  </Tab>
+  <Tab title="Windows (PowerShell)">
+    ```powershell
+    irm https://cdn.link-ai.tech/code/cow/run.ps1 | iex
+    ```
+  </Tab>
+</Tabs>
 
 デフォルトでは実行後に Web サービスが起動します。`http://localhost:9899/chat` にアクセスして Web インターフェースでチャットできます。
 

docs/ja/memory/context.mdx

@@ -0,0 +1,80 @@
+---
+title: 短期記憶
+description: 会話コンテキスト — メッセージ管理、圧縮戦略、コンテキスト操作
+---
+
+会話コンテキストは Agent の短期記憶であり、現在のセッション内のすべてのメッセージ（ユーザー入力、Agent の返信、ツール呼び出しと結果）を含みます。適切なコンテキスト管理は、Agent の推論品質とコスト制御にとって重要です。
+
+## コンテキストの構造
+
+各会話ターンは以下で構成されます：
+
+```
+ユーザーメッセージ → Agent の思考 → ツール呼び出し → ツール結果 → ... → Agent の最終返信
+```
+
+1 つのターンには複数のツール呼び出しが含まれる場合があります（`agent_max_steps` で制御）。すべてのツール呼び出しと結果は、圧縮またはトリミングされるまでコンテキストに保持されます。
+
+## 主要な設定
+
+| パラメータ | 説明 | デフォルト値 |
+| --- | --- | --- |
+| `agent_max_context_tokens` | コンテキストの最大トークン予算 | `50000` |
+| `agent_max_context_turns` | コンテキストの最大会話ターン数 | `20` |
+| `agent_max_steps` | ターンあたりの最大判断ステップ数（ツール呼び出し回数） | `15` |
+
+`config.json` またはチャットの `/config` コマンドで設定できます。
+
+## 圧縮戦略
+
+コンテキストが制限を超えた場合、システムは自動的に圧縮を実行してスペースを解放します。このプロセスには複数の段階があります：
+
+### 1. ツール結果の切り詰め
+
+各判断ループの開始前に、過去のターンのツール呼び出し結果を確認します。**20,000 文字** を超えるツール結果は切り詰められ、先頭と末尾のみが保持されます。現在のターンの結果は影響を受けません。
+
+### 2. ターンのトリミング
+
+会話ターン数が `agent_max_context_turns` を超えた場合：
+
+- **最も古い半分** の完全なターンがトリミングされます（ツール呼び出しチェーンの完全性を保証）
+- トリミングされたメッセージは LLM によって要約され、**日次記憶ファイルに書き込まれます**
+- 残りのターンはそのまま保持されます
+
+### 3. トークン予算のトリミング
+
+ターンのトリミング後、トークン数がまだ予算を超えている場合：
+
+- **5 ターン未満の場合**：すべてのターンで**テキスト圧縮**を実行 — 各ターンは最初のユーザーテキストと最後の Agent 返信のみを保持し、中間のツール呼び出しチェーンを削除
+- **5 ターン以上の場合**：**前半のターン**を再度トリミングし、破棄されたコンテンツも記憶に書き込まれます
+
+### 4. オーバーフロー緊急処理
+
+モデル API がコンテキストオーバーフローエラーを返した場合：
+
+1. 現在のすべてのメッセージを要約して記憶に書き込み
+2. 積極的なトリミングを適用（ツール結果は 10K 文字に制限、ユーザーテキストは 10K、最大 5 ターン）
+3. それでもオーバーフローする場合は、会話コンテキスト全体をクリア
+
+## セッションの永続化
+
+会話メッセージはローカルデータベースに永続化され、サービス再起動後に自動的に復元されます。復元戦略：
+
+- 最近の **`max(3, max_context_turns / 6)`** ターンを復元
+- 各ターンの**ユーザーテキストと Agent の最終返信のみ**を保持し、中間のツール呼び出しチェーンは復元しません
+- **30 日** を超える過去のセッションは自動的にクリーンアップされます
+
+## 操作コマンド
+
+チャットで以下のコマンドを使用してコンテキストを管理できます：
+
+| コマンド | 説明 |
+| --- | --- |
+| `/context` | 現在のコンテキスト統計を表示（メッセージ数、ロール分布、合計文字数） |
+| `/context clear` | 現在のセッションコンテキストをクリア |
+| `/config agent_max_context_tokens 80000` | コンテキストトークン予算を調整 |
+| `/config agent_max_context_turns 30` | コンテキストターン上限を調整 |
+
+<Tip>
+  コンテキストをクリアすると、Agent は以前の会話内容を「忘れます」。すでに長期記憶に書き込まれたコンテンツは、記憶検索を通じて引き続き取得できます。
+</Tip>

docs/ja/memory/index.mdx

@@ -1,25 +1,25 @@
 ---
-title: 記憶
-description: CowAgent 長期記憶システム
+title: 長期記憶
+description: CowAgent の長期記憶システム — ファイル永続化、自動書き込み、ハイブリッド検索
 ---
 
-記憶システムにより、Agent は重要な情報を長期にわたって記憶し、継続的に経験を蓄積し、ユーザーの好みを理解し、真に自律的な思考と継続的な成長を実現できます。
+長期記憶はワークスペースのファイルに保存され、セッション間で永続化されます。Agent は会話中に検索ツールを通じて過去の記憶をオンデマンドで読み込み、コンテキストのトリミング時に会話の要約を自動的に長期記憶に書き込みます。
 
 ## 記憶の種類
 
-### コア記憶 (MEMORY.md)
+### コア記憶（MEMORY.md）
 
-`~/cow/MEMORY.md` に保存され、長期的なユーザーの好み、重要な決定、主要な事実など、時間が経っても薄れない情報を含みます。毎回の会話ターンでバックグラウンド知識としてシステムプロンプトに自動的に注入されます。
+`~/cow/MEMORY.md` に保存され、長期的なユーザーの好み、重要な決定、主要な事実など、時間が経っても薄れない情報を含みます。Agent はツールを通じてこのファイルを読み書きし、長期的な知識を維持します。
 
-### 日次記憶 (memory/YYYY-MM-DD.md)
+### 日次記憶（memory/YYYY-MM-DD.md）
 
 `~/cow/memory/` ディレクトリに保存され、日付で命名されます（例：`2026-03-08.md`）。日々の会話の要約と主要なイベントを記録します。空ファイルの生成を避けるため、最初の書き込み時にのみファイルが作成されます。
 
-## 記憶の書き込み
+## 自動書き込み
 
-Agent は以下のメカニズムにより、会話内容を日次記憶に自動的に永続化します：
+Agent は以下のメカニズムにより、会話内容を長期記憶に自動的に永続化します：
 
-- **コンテキストトリミング時** — 会話ターン数またはトークン数が設定上限を超えた場合、コンテキストの古い半分が一括でトリミングされ、破棄されたコンテンツは LLM によって要約されて重要な情報として日次記憶ファイルに書き込まれます
+- **コンテキストトリミング時** — 会話ターン数またはトークン数が設定上限を超えた場合、最も古い半分のコンテキストがトリミングされ、LLM によって要約されて日次記憶ファイルに書き込まれます
 - **毎日のスケジュール要約** — 毎日 23:55 に自動的にフル要約がトリガーされ、アクティビティが少ない日でも記憶が保存されます（内容が変更されていない場合はスキップ）
 - **API コンテキストオーバーフロー時** — モデル API がコンテキストオーバーフローエラーを返した場合、緊急措置として現在の会話要約が保存されます
 
@@ -40,27 +40,10 @@ Agent は以下のメカニズムにより、会話内容を日次記憶に自
   <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
 </Frame>
 
-## 記憶の検索
-
-記憶システムはハイブリッド検索モードをサポートしています：
-
-- **キーワード検索** — キーワードに基づいて過去の記憶をマッチング
-- **ベクトル検索** — セマンティック類似性検索により、異なる表現でも関連する記憶を発見
-
-Agent は必要に応じて会話中に自動的に記憶検索をトリガーし、関連する過去の情報をコンテキストに組み込みます。コア記憶（`MEMORY.md`）は常にシステムプロンプトに注入され、日次記憶は検索を通じてオンデマンドで読み込まれます。
-
 ## 設定
 
-```json
-{
-  "agent_workspace": "~/cow",
-  "agent_max_context_tokens": 40000,
-  "agent_max_context_turns": 20
-}
-```
-
 | パラメータ | 説明 | デフォルト |
 | --- | --- | --- |
 | `agent_workspace` | ワークスペースパス、記憶ファイルはこのディレクトリ配下に保存されます | `~/cow` |
-| `agent_max_context_tokens` | 最大コンテキストトークン数。超過時に半分がトリミングされ、記憶として要約されます | `40000` |
-| `agent_max_context_turns` | 最大コンテキストターン数。超過時に半分がトリミングされ、記憶として要約されます | `20` |
+| `agent_max_context_tokens` | 最大コンテキストトークン数。超過時にトリミングされ、記憶として要約されます | `50000` |
+| `agent_max_context_turns` | 最大コンテキストターン数。超過時にトリミングされ、記憶として要約されます | `20` |

docs/ja/models/deepseek.mdx

@@ -3,7 +3,22 @@ title: DeepSeek
 description: DeepSeekモデルの設定
 ---
 
-OpenAI互換の設定を使用します:
+方法1：公式接続（推奨）：
+
+```json
+{
+  "model": "deepseek-chat",
+  "deepseek_api_key": "YOUR_API_KEY"
+}
+```
+
+| パラメータ | 説明 |
+| --- | --- |
+| `model` | `deepseek-chat`（DeepSeek-V3.2、非思考モード）、`deepseek-reasoner`（DeepSeek-R1、思考モード） |
+| `deepseek_api_key` | [DeepSeek Platform](https://platform.deepseek.com/api_keys)で作成 |
+| `deepseek_api_base` | オプション、デフォルトは `https://api.deepseek.com/v1`。サードパーティプロキシに変更可能 |
+
+方法2：OpenAI互換方式：
 
 ```json
 {
@@ -13,10 +28,3 @@ OpenAI互換の設定を使用します:
   "open_ai_api_base": "https://api.deepseek.com/v1"
 }
 ```
-
-| パラメータ | 説明 |
-| --- | --- |
-| `model` | `deepseek-chat` (DeepSeek-V3)、`deepseek-reasoner` (DeepSeek-R1) |
-| `bot_type` | `openai`を指定（OpenAI互換モード） |
-| `open_ai_api_key` | [DeepSeek Platform](https://platform.deepseek.com/api_keys)で作成 |
-| `open_ai_api_base` | DeepSeekプラットフォームのBASE URL |

docs/ja/skills/create.mdx

@@ -0,0 +1,58 @@
+---
+title: スキルの作成
+description: 会話を通じてカスタムスキルを作成
+---
+
+CowAgent には Skill Creator が組み込まれており、自然言語の会話を通じてスキルの作成、インストール、更新を素早く行えます。
+
+## 使い方
+
+会話で作りたいスキルを説明するだけで、Agent が自動的に作成します：
+
+- ワークフローをスキル化：「このデプロイプロセスからスキルを作成して」
+- サードパーティ API の統合：「この API ドキュメントに基づいてスキルを作成して」
+- リモートスキルのインストール：「xxx スキルをインストールして」
+
+## 作成フロー
+
+1. 作成したいスキルを Agent に伝えます
+2. Agent が自動的に `SKILL.md` の説明と実行スクリプトを生成します
+3. スキルはワークスペースの `~/cow/skills/` ディレクトリに保存されます
+4. 以降の会話で Agent が自動的にそのスキルを認識し使用します
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
+</Frame>
+
+## SKILL.md のフォーマット
+
+作成されたスキルは標準の SKILL.md フォーマットに従います：
+
+```markdown
+---
+name: my-skill
+description: Brief description of the skill
+metadata:
+  emoji: 🔧
+  requires:
+    bins: ["curl"]
+    env: ["MY_API_KEY"]
+  primaryEnv: "MY_API_KEY"
+---
+
+# My Skill
+
+Detailed instructions...
+```
+
+| フィールド | 説明 |
+| --- | --- |
+| `name` | スキル名。ディレクトリ名と一致する必要があります |
+| `description` | スキルの説明。Agent はこれに基づいて呼び出すかどうかを判断します |
+| `metadata.requires.bins` | 必要なシステムコマンド |
+| `metadata.requires.env` | 必要な環境変数 |
+| `metadata.always` | 常に読み込む（デフォルトは false） |
+
+<Tip>
+  詳細は [Skill Creator のドキュメント](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)をご覧ください。
+</Tip>

docs/ja/skills/image-vision.mdx

@@ -1,31 +0,0 @@
----
-title: Image Vision
-description: OpenAI の Vision モデルを使用して画像を認識
----
-
-OpenAI の GPT-4 Vision API を使用して画像の内容を分析し、画像内のオブジェクト、テキスト、色などの要素を理解します。
-
-## 依存関係
-
-| 依存関係 | 説明 |
-| --- | --- |
-| `OPENAI_API_KEY` | OpenAI API キー |
-| `curl`, `base64` | システムコマンド（通常プリインストール済み） |
-
-設定方法：
-
-- `env_config` Tool で `OPENAI_API_KEY` を設定
-- または `config.json` で `open_ai_api_key` を設定
-
-## 対応モデル
-
-- `gpt-4.1-mini`（推奨、コストパフォーマンスに優れる）
-- `gpt-4.1`
-
-## 使い方
-
-設定が完了したら、Agent に画像を送信すると自動的に画像認識がトリガーされます。
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
-</Frame>

docs/ja/skills/index.mdx

@@ -1,35 +1,32 @@
 ---
-title: Skill 概要
-description: CowAgent の Skill システム紹介
+title: スキル概要
+description: CowAgent のスキルシステム紹介
 ---
 
-Skill は Agent に無限の拡張性を提供します。各 Skill は説明ファイル（`SKILL.md`）、実行スクリプト（任意）、リソース（任意）で構成され、特定のタスクをどのように遂行するかを記述します。
+スキル（Skill）は Agent に無限の拡張性を提供します。各スキルは説明ファイル（`SKILL.md`）、実行スクリプト（任意）、リソース（任意）で構成され、特定のタスクをどのように遂行するかを記述します。
 
-Skill と Tool の違い：Tool はコードで実装された原子的な操作（例：ファイルの読み書き、コマンドの実行）であるのに対し、Skill は説明ファイルに基づく高レベルなワークフローであり、複数の Tool を組み合わせて複雑なタスクを完遂できます。
+スキルとツールの違い：ツールはコードで実装された原子的な操作（例：ファイルの読み書き、コマンドの実行）であるのに対し、スキルは説明ファイルに基づく高レベルなワークフローであり、複数のツールを組み合わせて複雑なタスクを完遂できます。
 
-## 組み込み Skill
+## スキルの取得
 
-プロジェクトの `skills/` ディレクトリに配置されており、依存条件に基づいて自動的に有効化されます：
+CowAgent ではスキルを取得する複数の方法を提供しています：
 
-| Skill | 説明 | 依存関係 |
-| --- | --- | --- |
-| [`skill-creator`](/ja/skills/skill-creator) | 会話を通じてカスタム Skill を作成 | なし |
-| [`openai-image-vision`](/ja/skills/image-vision) | OpenAI の Vision モデルを使用して画像を認識 | `OPENAI_API_KEY` |
-| [`linkai-agent`](/ja/skills/linkai-agent) | LinkAI プラットフォームの Agent を統合 | `LINKAI_API_KEY` |
-| [`web-fetch`](/ja/skills/web-fetch) | Web ページのテキストコンテンツを取得 | `curl`（デフォルトで有効） |
+- **Cow スキル広場** — `/skill list --remote` でコミュニティスキルを閲覧・インストール
+- **GitHub** — GitHub リポジトリから直接インストール、バッチインストールにも対応
+- **ClawHub** — `/skill install clawhub:名前` で ClawHub のスキルをインストール
+- **URL** — zip アーカイブや SKILL.md リンクからインストール
+- **会話で作成** — 自然言語の会話を通じて Agent にスキルを自動作成させる
 
-## カスタム Skill
+詳細は[スキルのインストール](/ja/skills/install)と[スキル管理コマンド](/ja/commands/skill)を参照してください。会話を通じて[スキルを作成](/ja/skills/create)することもできます。
 
-ユーザーが会話を通じて作成し、ワークスペース（`~/cow/skills/`）に保存されます。任意の複雑なビジネスプロセスやサードパーティシステムとの連携を実装できます。
+## スキルの読み込み優先順位
 
-## Skill の読み込み優先順位
+1. **ワークスペースのスキル**（最高優先）：`~/cow/skills/`
+2. **プロジェクト組み込みスキル**（最低優先）：`skills/`
 
-1. **ワークスペースの Skill**（最高優先）：`~/cow/skills/`
-2. **プロジェクト組み込み Skill**（最低優先）：`skills/`
+同名のスキルは優先順位に従って上書きされます。
 
-同名の Skill は優先順位に従って上書きされます。
-
-## Skill のファイル構成
+## スキルのファイル構成
 
 ```
 skills/
@@ -60,8 +57,8 @@ Detailed instructions...
 
 | フィールド | 説明 |
 | --- | --- |
-| `name` | Skill 名。ディレクトリ名と一致する必要があります |
-| `description` | Skill の説明。Agent はこれに基づいて呼び出すかどうかを判断します |
+| `name` | スキル名。ディレクトリ名と一致する必要があります |
+| `description` | スキルの説明。Agent はこれに基づいて呼び出すかどうかを判断します |
 | `metadata.requires.bins` | 必要なシステムコマンド |
 | `metadata.requires.env` | 必要な環境変数 |
 | `metadata.always` | 常に読み込む（デフォルトは false） |

docs/ja/skills/install.mdx

@@ -0,0 +1,53 @@
+---
+title: スキルのインストール
+description: 統一コマンドで多様なソースからスキルをインストール
+---
+
+CowAgent は統一された `install` コマンドで、**Cow スキル広場、GitHub、ClawHub** および任意の URL からスキルをインストールできます。チャットでは `/skill install`、ターミナルでは `cow skill install` を使用します。
+
+## スキル広場からインストール
+
+スキル広場を閲覧してインストール：
+
+```text
+/skill list --remote
+/skill install pptx
+```
+
+## GitHub からインストール
+
+リポジトリからの一括インストールとサブディレクトリ指定に対応：
+
+```text
+/skill install larksuite/cli
+/skill install https://github.com/larksuite/cli/tree/main/skills/lark-im
+```
+
+## ClawHub からインストール
+
+```text
+/skill install clawhub:baidu-search
+```
+
+## URL からインストール
+
+zip アーカイブと SKILL.md ファイルリンクに対応：
+
+```text
+/skill install https://cdn.link-ai.tech/skills/pptx.zip
+/skill install https://example.com/path/to/SKILL.md
+```
+
+## スキルの管理
+
+```text
+/skill list                  # インストール済みスキルを表示
+/skill info pptx             # スキルの詳細を表示
+/skill enable pptx           # スキルを有効化
+/skill disable pptx          # スキルを無効化
+/skill uninstall pptx        # スキルをアンインストール
+```
+
+<Tip>
+  上記のすべてのコマンドは、ターミナルでは `/skill` を `cow skill` に置き換えて使用できます。完全なコマンドドキュメントは[スキル管理コマンド](/ja/commands/skill)を参照してください。
+</Tip>

docs/ja/skills/linkai-agent.mdx

@@ -1,47 +0,0 @@
----
-title: LinkAI Agent
-description: LinkAI プラットフォームのマルチ Agent Skill を統合
----
-
-[LinkAI](https://link-ai.tech/) プラットフォームの Agent を Skill として使用し、マルチ Agent の意思決定を行います。Agent は Agent 名と説明に基づいてインテリジェントに選択し、`app_code` を通じて対応するアプリケーションやワークフローを呼び出します。
-
-## 依存関係
-
-| 依存関係 | 説明 |
-| --- | --- |
-| `LINKAI_API_KEY` | LinkAI プラットフォームの API キー。[コンソール](https://link-ai.tech/console/interface)で作成 |
-| `curl` | システムコマンド（通常プリインストール済み） |
-
-設定方法：
-
-- `env_config` Tool で `LINKAI_API_KEY` を設定
-- または `config.json` で `linkai_api_key` を設定
-
-## Agent の設定
-
-`skills/linkai-agent/config.json` で利用可能な Agent を追加します：
-
-```json
-{
-  "apps": [
-    {
-      "app_code": "G7z6vKwp",
-      "app_name": "LinkAI Customer Support",
-      "app_description": "Select this assistant only when the user needs help with LinkAI platform questions"
-    },
-    {
-      "app_code": "SFY5x7JR",
-      "app_name": "Content Creator",
-      "app_description": "Use this assistant only when the user needs to create images or videos"
-    }
-  ]
-}
-```
-
-## 使い方
-
-設定が完了すると、Agent はユーザーの質問に基づいて適切な LinkAI Agent を自動的に選択します。
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202234350.png" width="750" />
-</Frame>

docs/ja/skills/skill-creator.mdx

@@ -1,31 +0,0 @@
----
-title: Skill Creator
-description: 会話を通じてカスタム Skill を作成
----
-
-自然言語の会話を通じて、Skill の作成、インストール、更新を素早く行えます。
-
-## 依存関係
-
-追加の依存関係は不要で、常に利用可能です。
-
-## 使い方
-
-- ワークフローを Skill 化：「このデプロイプロセスから Skill を作成して」
-- サードパーティ API の統合：「この API ドキュメントに基づいて Skill を作成して」
-- リモート Skill のインストール：「xxx Skill をインストールして」
-
-## 作成フロー
-
-1. 作成したい Skill を Agent に伝えます
-2. Agent が自動的に `SKILL.md` の説明と実行スクリプトを生成します
-3. Skill はワークスペースの `~/cow/skills/` ディレクトリに保存されます
-4. 以降の会話で Agent が自動的にその Skill を認識し使用します
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
-</Frame>
-
-<Tip>
-  詳細は [Skill Creator のドキュメント](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)をご覧ください。
-</Tip>

docs/ja/skills/web-fetch.mdx

@@ -1,31 +0,0 @@
----
-title: Web Fetch
-description: Web ページのテキストコンテンツを取得
----
-
-curl を使用して Web ページを取得し、読み取り可能なテキストコンテンツを抽出します。ブラウザ自動化を必要としない軽量な Web アクセス方法です。
-
-## 依存関係
-
-| 依存関係 | 説明 |
-| --- | --- |
-| `curl` | システムコマンド（通常プリインストール済み） |
-
-この Skill は `always: true` が設定されており、システムに `curl` コマンドがあればデフォルトで有効になります。
-
-## 使い方
-
-Agent が URL からコンテンツを取得する必要がある場合に自動的に呼び出されます。追加の設定は不要です。
-
-## browser Tool との比較
-
-| 機能 | web-fetch (Skill) | browser (Tool) |
-| --- | --- | --- |
-| 依存関係 | curl のみ | browser-use + playwright |
-| JS レンダリング | 非対応 | 対応 |
-| ページ操作 | 非対応 | クリック、入力などに対応 |
-| 最適な用途 | 静的ページのテキスト | 動的な Web ページ |
-
-<Tip>
-  ほとんどの Web コンテンツ取得シナリオでは、web-fetch で十分です。JS レンダリングやページ操作が必要な場合にのみ browser Tool を使用してください。
-</Tip>

docs/memory/context.mdx

@@ -0,0 +1,80 @@
+---
+title: 短期记忆
+description: 对话上下文 — 消息管理、压缩策略和上下文操作
+---
+
+对话上下文是 Agent 的短期记忆，包含当前会话中的所有消息（用户输入、Agent 回复、工具调用及结果）。合理管理上下文对于 Agent 的推理质量和成本控制至关重要。
+
+## 上下文结构
+
+每一轮对话由以下消息组成：
+
+```
+用户消息 → Agent 思考 → 工具调用 → 工具结果 → ... → Agent 最终回复
+```
+
+一轮中可能包含多次工具调用（Agent 的决策步数由 `agent_max_steps` 控制），所有工具调用和结果都会保留在上下文中，直到被压缩或裁剪。
+
+## 关键配置
+
+| 参数 | 说明 | 默认值 |
+| --- | --- | --- |
+| `agent_max_context_tokens` | 上下文最大 token 预算 | `50000` |
+| `agent_max_context_turns` | 上下文最大对话轮次 | `20` |
+| `agent_max_steps` | 单轮对话最大决策步数（工具调用次数） | `15` |
+
+可通过 `config.json` 或对话中的 `/config` 命令修改。
+
+## 压缩策略
+
+当上下文超出限制时，系统会自动执行压缩以释放空间。整个过程分为多个阶段：
+
+### 1. 工具结果截断
+
+在每次决策循环开始前，系统会检查历史轮次中的工具调用结果。超过 **20000 字符** 的工具结果会被截断，仅保留首尾内容和截断说明。当前轮次的工具结果不受影响。
+
+### 2. 轮次裁剪
+
+当对话轮次超过 `agent_max_context_turns` 时：
+
+- 裁剪 **最早一半** 的完整轮次（保证工具调用链的完整性）
+- 被裁剪的消息会通过 LLM 总结后**写入当天的日级记忆文件**
+- 剩余轮次保持不变
+
+### 3. Token 预算裁剪
+
+裁剪轮次后，如果 token 数仍超出预算：
+
+- **轮次 < 5 时**：对所有轮次进行**文本压缩** — 每轮只保留第一条用户文本和最后一条 Agent 回复，去掉中间的工具调用链
+- **轮次 ≥ 5 时**：再次裁剪**前半轮次**，被丢弃内容同样写入记忆
+
+### 4. 溢出应急处理
+
+当模型 API 返回上下文溢出错误时：
+
+1. 先将当前所有消息总结写入记忆
+2. 执行激进裁剪（工具结果限制 10K 字符、用户文本限制 10K、最多保留 5 轮）
+3. 如果仍然溢出，清空整个对话上下文
+
+## 会话持久化
+
+对话消息会持久化到本地数据库，服务重启后自动恢复。恢复策略：
+
+- 恢复最近的 **`max(3, max_context_turns / 6)`** 轮对话
+- 只保留每轮的**用户文本和 Agent 最终回复**，不恢复中间工具调用链
+- 超过 **30 天**的历史会话自动清理
+
+## 操作命令
+
+在对话中可以使用以下命令管理上下文：
+
+| 命令 | 说明 |
+| --- | --- |
+| `/context` | 查看当前上下文统计（消息数、角色分布、总字符数） |
+| `/context clear` | 清空当前会话上下文 |
+| `/config agent_max_context_tokens 80000` | 调整上下文 token 预算 |
+| `/config agent_max_context_turns 30` | 调整上下文轮次上限 |
+
+<Tip>
+  清空上下文后，Agent 会"忘记"之前的对话内容。被裁剪和清空的内容如果已经写入长期记忆，仍可通过记忆检索找回。
+</Tip>

docs/memory/index.mdx

@@ -1,30 +1,39 @@
 ---
 title: 长期记忆
-description: CowAgent 的长期记忆系统
+description: CowAgent 的长期记忆系统 — 文件持久化、自动写入与混合检索
 ---
 
-记忆系统让 Agent 能够长期记住重要信息，在对话中不断积累经验、理解用户偏好，真正实现自主思考和持续成长。
+长期记忆保存在工作空间文件中，跨会话持久存在。Agent 在对话中通过检索工具按需加载历史记忆，也会在上下文裁剪时自动将对话摘要写入长期记忆。
 
 ## 记忆类型
 
 ### 核心记忆（MEMORY.md）
 
-存储在 `~/cow/MEMORY.md` 中，包含用户的长期偏好、重要决策、关键事实等不会随时间淡化的信息。每次对话时自动注入系统提示词，作为 Agent 的背景知识。
+存储在 `~/cow/MEMORY.md` 中，包含用户的长期偏好、重要决策、关键事实等不会随时间淡化的信息。Agent 可通过工具读写此文件来维护长期知识。
 
-### 天级记忆（memory/YYYY-MM-DD.md）
+### 日级记忆（memory/YYYY-MM-DD.md）
 
 存储在 `~/cow/memory/` 目录下，按日期命名（如 `2026-03-08.md`），记录每天的对话摘要和关键事件。仅在首次写入时创建，避免生成空文件。
 
-## 记忆写入
+## 自动写入
 
-Agent 通过以下机制自动将对话内容持久化为天级记忆：
+Agent 通过以下机制自动将对话内容持久化为长期记忆：
 
-- **上下文裁剪时** — 当对话轮次或 token 超出配置上限时，批量裁剪最早一半的上下文，并使用 LLM 将被裁剪的内容总结为关键信息写入当天记忆文件
+- **上下文裁剪时** — 当对话轮次或 token 超出配置上限时，裁剪最早一半的上下文，使用 LLM 将被裁剪的内容总结为关键信息写入当天记忆文件
 - **每日定时总结** — 每天 23:55 自动触发一次全量总结，防止低活跃日无记忆留存（内容无变化时自动跳过）
 - **API 上下文溢出时** — 当模型 API 返回上下文溢出错误时，紧急保存当前对话摘要
 
 所有记忆写入均在后台异步执行（LLM 总结 + 文件写入），不阻塞正常对话回复。
 
+## 记忆检索
+
+记忆系统支持混合检索模式：
+
+- **关键词检索** — 基于 FTS5 全文索引匹配历史记忆，支持 BM25 排序
+- **向量检索** — 基于 embedding 语义相似度搜索，即使表述不同也能找到相关记忆
+
+Agent 会在对话中根据需要自动触发记忆检索，将相关历史信息纳入上下文。检索结果按混合评分排序（默认向量权重 0.7、关键词权重 0.3），日级记忆会随时间衰减（半衰期 30 天），核心记忆不衰减。
+
 ## 首次启动
 
 首次启动 Agent 时，Agent 会主动向用户询问关键信息，并记录至工作空间（默认 `~/cow`）中：
@@ -34,33 +43,16 @@ Agent 通过以下机制自动将对话内容持久化为天级记忆：
 | `system.md` | Agent 的系统提示词和行为设定 |
 | `user.md` | 用户身份信息和偏好 |
 | `MEMORY.md` | 核心记忆（长期） |
-| `memory/YYYY-MM-DD.md` | 天级记忆（按需创建） |
+| `memory/YYYY-MM-DD.md` | 日级记忆（按需创建） |
 
 <Frame>
   <img src="https://cdn.link-ai.tech/doc/20260203000455.png" width="800" />
 </Frame>
 
-## 记忆检索
-
-记忆系统支持混合检索模式：
-
-- **关键词检索** — 基于关键词匹配历史记忆
-- **向量检索** — 基于语义相似度搜索，即使表述不同也能找到相关记忆
-
-Agent 会在对话中根据需要自动触发记忆检索，将相关历史信息纳入上下文。核心记忆（`MEMORY.md`）始终注入系统提示词，天级记忆通过检索按需加载。
-
 ## 相关配置
 
-```json
-{
-  "agent_workspace": "~/cow",
-  "agent_max_context_tokens": 40000,
-  "agent_max_context_turns": 20
-}
-```
-
 | 参数 | 说明 | 默认值 |
 | --- | --- | --- |
 | `agent_workspace` | 工作空间路径，记忆文件存储在此目录下 | `~/cow` |
-| `agent_max_context_tokens` | 最大上下文 token 数，超出时裁剪一半并总结写入记忆 | `40000` |
-| `agent_max_context_turns` | 最大上下文轮次，超出时裁剪一半并总结写入记忆 | `20` |
+| `agent_max_context_tokens` | 最大上下文 token 数，超出时裁剪并总结写入记忆 | `50000` |
+| `agent_max_context_turns` | 最大上下文轮次，超出时裁剪并总结写入记忆 | `20` |

docs/models/deepseek.mdx

@@ -3,20 +3,29 @@ title: DeepSeek
 description: DeepSeek 模型配置
 ---
 
-通过 OpenAI 兼容方式接入：
+方式一：官方接入（推荐）：
 
 ```json
 {
   "model": "deepseek-chat",
-  "open_ai_api_key": "YOUR_API_KEY",
-  "open_ai_api_base": "https://api.deepseek.com/v1",
-  "bot_type": "openai"
+  "deepseek_api_key": "YOUR_API_KEY"
 }
 ```
 
 | 参数 | 说明 |
 | --- | --- |
-| `model` | `deepseek-chat`（DeepSeek-V3）、`deepseek-reasoner`（DeepSeek-R1） |
-| `bot_type` | 固定为 `openai`（OpenAI 兼容方式） |
-| `open_ai_api_key` | 在 [DeepSeek 平台](https://platform.deepseek.com/api_keys) 创建 |
-| `open_ai_api_base` | DeepSeek 平台 BASE URL |
+| `model` | `deepseek-chat`（DeepSeek-V3.2，非思考模式）、`deepseek-reasoner`（DeepSeek-R1，思考模式） |
+| `deepseek_api_key` | 在 [DeepSeek 平台](https://platform.deepseek.com/api_keys) 创建 |
+| `deepseek_api_base` | 可选，默认为 `https://api.deepseek.com/v1`，可修改为第三方代理地址 |
+
+方式二：OpenAI 兼容方式接入：
+
+```json
+{
+  "model": "deepseek-chat",
+  "bot_type": "openai",
+  "open_ai_api_key": "YOUR_API_KEY",
+  "open_ai_api_base": "https://api.deepseek.com/v1"
+}
+```
+

docs/skills/create.mdx

@@ -0,0 +1,58 @@
+---
+title: 创建技能
+description: 通过对话创建自定义技能
+---
+
+CowAgent 内置了 Skill Creator，可以通过自然语言对话快速创建、安装或更新技能。
+
+## 使用方式
+
+直接在对话中描述你想要的技能，Agent 会自动完成创建：
+
+- 将工作流程固化为技能："帮我把这个部署流程创建为一个技能"
+- 对接第三方 API："根据这个接口文档创建一个技能"
+- 安装远程技能："帮我安装 xxx 技能"
+
+## 创建流程
+
+1. 告诉 Agent 你想创建的技能功能
+2. Agent 自动生成 `SKILL.md` 说明文件和运行脚本
+3. 技能保存到工作空间的 `~/cow/skills/` 目录
+4. 后续对话中 Agent 会自动识别并使用该技能
+
+<Frame>
+  <img src="https://cdn.link-ai.tech/doc/20260202202247.png" width="800" />
+</Frame>
+
+## SKILL.md 格式
+
+创建的技能遵循标准的 SKILL.md 格式：
+
+```markdown
+---
+name: my-skill
+description: Brief description of the skill
+metadata:
+  emoji: 🔧
+  requires:
+    bins: ["curl"]
+    env: ["MY_API_KEY"]
+  primaryEnv: "MY_API_KEY"
+---
+
+# My Skill
+
+Detailed instructions...
+```
+
+| 字段 | 说明 |
+| --- | --- |
+| `name` | 技能名称，需与目录名一致 |
+| `description` | 技能描述，Agent 据此决定是否调用 |
+| `metadata.requires.bins` | 依赖的系统命令 |
+| `metadata.requires.env` | 依赖的环境变量 |
+| `metadata.always` | 是否始终加载（默认 false） |
+
+<Tip>
+  详细开发文档可参考 [Skill Creator 说明](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)。
+</Tip>

docs/skills/image-vision.mdx

@@ -1,31 +0,0 @@
----
-title: 图像识别
-description: 使用 OpenAI 视觉模型识别图片
----
-
-使用 OpenAI 的 GPT-4 Vision API 分析图片内容，理解图像中的物体、文字、颜色等元素。
-
-## 依赖
-
-| 依赖 | 说明 |
-| --- | --- |
-| `OPENAI_API_KEY` | OpenAI API 密钥 |
-| `curl`、`base64` | 系统命令（通常已预装） |
-
-配置方式：
-
-- 通过 `env_config` 工具配置 `OPENAI_API_KEY`
-- 或在 `config.json` 中填写 `open_ai_api_key`
-
-## 支持的模型
-
-- `gpt-4.1-mini`（推荐，性价比高）
-- `gpt-4.1`
-
-## 使用方式
-
-配置完成后，向 Agent 发送图片即可自动触发图像识别。
-
-<Frame>
-  <img src="https://cdn.link-ai.tech/doc/20260202213219.png" width="800" />
-</Frame>